From 040f76ba2110118ba79e193032b4208c6f333ba9 Mon Sep 17 00:00:00 2001 From: Nicolas De Loof Date: Thu, 18 Sep 2025 15:39:11 +0200 Subject: [PATCH] use interfaces Signed-off-by: Nicolas De Loof --- src/models/Address.ts | 35 +- src/models/AuthConfig.ts | 43 ++- src/models/BuildCache.ts | 79 +++-- src/models/BuildInfo.ts | 47 ++- src/models/BuildPruneResponse.ts | 35 +- src/models/ChangeType.ts | 34 +- src/models/ClusterInfo.ts | 59 ++-- src/models/ClusterVolume.ts | 50 ++- src/models/ClusterVolumeInfo.ts | 43 ++- src/models/ClusterVolumePublishStatusInner.ts | 51 +-- src/models/ClusterVolumeSpec.ts | 35 +- src/models/ClusterVolumeSpecAccessMode.ts | 83 +++-- ...SpecAccessModeAccessibilityRequirements.ts | 35 +- ...lusterVolumeSpecAccessModeCapacityRange.ts | 35 +- ...ClusterVolumeSpecAccessModeSecretsInner.ts | 35 +- src/models/Commit.ts | 32 +- src/models/Config.ts | 44 ++- src/models/ConfigCreateRequest.ts | 41 ++- src/models/ConfigReference.ts | 34 +- src/models/ConfigSpec.ts | 41 ++- src/models/ContainerBlkioStatEntry.ts | 41 ++- src/models/ContainerBlkioStats.ts | 67 ++-- src/models/ContainerCPUStats.ts | 41 ++- src/models/ContainerCPUUsage.ts | 47 ++- src/models/ContainerConfig.ts | 128 ++++--- src/models/ContainerCreateRequest.ts | 134 +++++--- src/models/ContainerCreateResponse.ts | 35 +- src/models/ContainerInspectResponse.ts | 121 ++++--- src/models/ContainerMemoryStats.ts | 55 +-- src/models/ContainerNetworkStats.ts | 59 ++-- src/models/ContainerPidsStats.ts | 37 +- src/models/ContainerPruneResponse.ts | 35 +- src/models/ContainerState.ts | 86 +++-- src/models/ContainerStatsResponse.ts | 67 ++-- src/models/ContainerStatus.ts | 38 ++- src/models/ContainerStorageStats.ts | 41 ++- src/models/ContainerSummary.ts | 103 +++--- src/models/ContainerSummaryHealth.ts | 46 +-- src/models/ContainerSummaryHostConfig.ts | 37 +- src/models/ContainerSummaryNetworkSettings.ts | 32 +- src/models/ContainerThrottlingData.ts | 38 ++- src/models/ContainerTopResponse.ts | 35 +- src/models/ContainerUpdateRequest.ts | 155 +++++---- src/models/ContainerUpdateResponse.ts | 32 +- src/models/ContainerWaitExitError.ts | 32 +- src/models/ContainerWaitResponse.ts | 35 +- src/models/ContainerdInfo.ts | 35 +- src/models/ContainerdInfoNamespaces.ts | 39 ++- src/models/CreateImageInfo.ts | 41 ++- src/models/DeviceInfo.ts | 37 +- src/models/DeviceMapping.ts | 38 ++- src/models/DeviceRequest.ts | 44 ++- src/models/DistributionInspect.ts | 35 +- src/models/Driver.ts | 35 +- src/models/DriverData.ts | 35 +- src/models/EndpointIPAMConfig.ts | 38 ++- src/models/EndpointPortConfig.ts | 57 ++-- src/models/EndpointResource.ts | 44 ++- src/models/EndpointSettings.ts | 76 +++-- src/models/EndpointSpec.ts | 42 ++- src/models/EngineDescription.ts | 38 ++- src/models/EngineDescriptionPluginsInner.ts | 35 +- src/models/ErrorDetail.ts | 35 +- src/models/ErrorResponse.ts | 32 +- src/models/EventActor.ts | 35 +- src/models/EventMessage.ts | 79 +++-- src/models/ExecConfig.ts | 76 +++-- src/models/ExecInspectResponse.ts | 62 ++-- src/models/ExecStartConfig.ts | 40 ++- src/models/FilesystemChange.ts | 35 +- src/models/FirewallInfo.ts | 37 +- src/models/GenericResourcesInner.ts | 35 +- ...nericResourcesInnerDiscreteResourceSpec.ts | 35 +- .../GenericResourcesInnerNamedResourceSpec.ts | 35 +- src/models/Health.ts | 47 +-- src/models/HealthConfig.ts | 49 ++- src/models/HealthcheckResult.ts | 43 ++- src/models/HistoryResponseItem.ts | 47 ++- src/models/HostConfig.ts | 317 +++++++++++------- src/models/HostConfigAllOfLogConfig.ts | 60 ++-- src/models/IDResponse.ts | 32 +- src/models/IPAM.ts | 40 ++- src/models/IPAMConfig.ts | 41 ++- src/models/ImageConfig.ts | 78 +++-- src/models/ImageDeleteResponseItem.ts | 35 +- src/models/ImageID.ts | 32 +- src/models/ImageInspect.ts | 95 ++++-- src/models/ImageInspectMetadata.ts | 32 +- src/models/ImageInspectRootFS.ts | 35 +- src/models/ImageManifestSummary.ts | 56 ++-- .../ImageManifestSummaryAttestationData.ts | 32 +- src/models/ImageManifestSummaryImageData.ts | 38 ++- .../ImageManifestSummaryImageDataSize.ts | 34 +- src/models/ImageManifestSummarySize.ts | 37 +- src/models/ImagePruneResponse.ts | 35 +- src/models/ImageSearchResponseItem.ts | 46 ++- src/models/ImageSummary.ts | 73 ++-- src/models/IndexInfo.ts | 45 ++- src/models/JoinTokens.ts | 35 +- src/models/Limit.ts | 40 ++- src/models/LocalNodeState.ts | 43 ++- src/models/ManagerStatus.ts | 38 ++- src/models/Mount.ts | 75 +++-- src/models/MountBindOptions.ts | 63 ++-- src/models/MountImageOptions.ts | 32 +- src/models/MountPoint.ts | 78 +++-- src/models/MountTmpfsOptions.ts | 38 ++- src/models/MountVolumeOptions.ts | 41 ++- src/models/MountVolumeOptionsDriverConfig.ts | 35 +- src/models/Network.ts | 81 +++-- src/models/NetworkAttachmentConfig.ts | 38 ++- src/models/NetworkConnectRequest.ts | 35 +- src/models/NetworkCreateRequest.ts | 72 ++-- src/models/NetworkCreateResponse.ts | 35 +- src/models/NetworkDisconnectRequest.ts | 35 +- src/models/NetworkInspect.ts | 87 +++-- src/models/NetworkPruneResponse.ts | 32 +- src/models/NetworkSettings.ts | 105 +++--- src/models/NetworkSummary.ts | 81 +++-- src/models/NetworkTaskInfo.ts | 41 ++- src/models/NetworkingConfig.ts | 32 +- src/models/Node.ts | 53 +-- src/models/NodeDescription.ts | 44 ++- src/models/NodeSpec.ts | 52 +-- src/models/NodeState.ts | 35 +- src/models/NodeStatus.ts | 38 ++- src/models/OCIDescriptor.ts | 53 +-- src/models/OCIPlatform.ts | 54 +-- src/models/ObjectVersion.ts | 32 +- src/models/PeerInfo.ts | 35 +- src/models/PeerNode.ts | 35 +- src/models/Platform.ts | 39 ++- src/models/Plugin.ts | 47 ++- src/models/PluginConfig.ts | 77 +++-- src/models/PluginConfigArgs.ts | 41 ++- src/models/PluginConfigInterface.ts | 45 ++- src/models/PluginConfigLinux.ts | 38 ++- src/models/PluginConfigNetwork.ts | 32 +- src/models/PluginConfigRootfs.ts | 35 +- src/models/PluginConfigUser.ts | 35 +- src/models/PluginDevice.ts | 41 ++- src/models/PluginEnv.ts | 41 ++- src/models/PluginMount.ts | 50 ++- src/models/PluginPrivilege.ts | 38 ++- src/models/PluginSettings.ts | 41 ++- src/models/PluginsInfo.ts | 41 ++- src/models/PortBinding.ts | 39 ++- src/models/PortStatus.ts | 32 +- src/models/PortSummary.ts | 49 +-- src/models/ProcessConfig.ts | 44 ++- src/models/ProgressDetail.ts | 35 +- src/models/PushImageInfo.ts | 38 ++- src/models/Reachability.ts | 34 +- src/models/RegistryServiceConfig.ts | 42 ++- src/models/ResourceObject.ts | 40 ++- src/models/Resources.ts | 152 +++++---- src/models/ResourcesBlkioWeightDeviceInner.ts | 35 +- src/models/ResourcesUlimitsInner.ts | 38 ++- src/models/RestartPolicy.ts | 52 +-- src/models/Runtime.ts | 42 ++- src/models/Secret.ts | 44 ++- src/models/SecretCreateRequest.ts | 44 ++- src/models/SecretSpec.ts | 44 ++- src/models/Service.ts | 56 ++-- src/models/ServiceCreateRequest.ts | 53 +-- src/models/ServiceCreateResponse.ts | 37 +- src/models/ServiceEndpoint.ts | 38 ++- src/models/ServiceEndpointVirtualIPsInner.ts | 35 +- src/models/ServiceInfo.ts | 41 ++- src/models/ServiceJobStatus.ts | 35 +- src/models/ServiceServiceStatus.ts | 38 ++- src/models/ServiceSpec.ts | 53 +-- src/models/ServiceSpecMode.ts | 41 ++- src/models/ServiceSpecModeReplicated.ts | 32 +- src/models/ServiceSpecModeReplicatedJob.ts | 37 +- src/models/ServiceSpecRollbackConfig.ts | 57 ++-- src/models/ServiceSpecUpdateConfig.ts | 61 ++-- src/models/ServiceUpdateRequest.ts | 53 +-- src/models/ServiceUpdateResponse.ts | 32 +- src/models/ServiceUpdateStatus.ts | 47 +-- src/models/Swarm.ts | 62 ++-- src/models/SwarmInfo.ts | 58 ++-- src/models/SwarmInitRequest.ts | 59 ++-- src/models/SwarmJoinRequest.ts | 48 ++- src/models/SwarmSpec.ts | 53 +-- src/models/SwarmSpecCAConfig.ts | 46 ++- .../SwarmSpecCAConfigExternalCAsInner.ts | 47 +-- src/models/SwarmSpecDispatcher.ts | 32 +- src/models/SwarmSpecEncryptionConfig.ts | 32 +- src/models/SwarmSpecOrchestration.ts | 32 +- src/models/SwarmSpecRaft.ts | 46 ++- src/models/SwarmSpecTaskDefaults.ts | 32 +- src/models/SwarmSpecTaskDefaultsLogDriver.ts | 35 +- src/models/SwarmUnlockRequest.ts | 34 +- src/models/SystemAuthResponse.ts | 35 +- src/models/SystemDataUsageResponse.ts | 44 ++- src/models/SystemInfo.ts | 285 +++++++++------- .../SystemInfoDefaultAddressPoolsInner.ts | 35 +- src/models/SystemVersion.ts | 69 ++-- src/models/SystemVersionComponentsInner.ts | 38 ++- src/models/SystemVersionPlatform.ts | 32 +- src/models/TLSInfo.ts | 38 ++- src/models/Task.ts | 73 ++-- src/models/TaskSpec.ts | 59 ++-- src/models/TaskSpecContainerSpec.ts | 136 +++++--- .../TaskSpecContainerSpecConfigsInner.ts | 45 ++- .../TaskSpecContainerSpecConfigsInnerFile.ts | 41 ++- src/models/TaskSpecContainerSpecDNSConfig.ts | 40 ++- src/models/TaskSpecContainerSpecPrivileges.ts | 44 ++- ...TaskSpecContainerSpecPrivilegesAppArmor.ts | 39 ++- ...ecContainerSpecPrivilegesCredentialSpec.ts | 44 ++- ...ecContainerSpecPrivilegesSELinuxContext.ts | 44 ++- .../TaskSpecContainerSpecPrivilegesSeccomp.ts | 44 ++- .../TaskSpecContainerSpecSecretsInner.ts | 40 ++- .../TaskSpecContainerSpecSecretsInnerFile.ts | 41 ++- src/models/TaskSpecLogDriver.ts | 35 +- src/models/TaskSpecNetworkAttachmentSpec.ts | 32 +- src/models/TaskSpecPlacement.ts | 45 ++- .../TaskSpecPlacementPreferencesInner.ts | 32 +- ...TaskSpecPlacementPreferencesInnerSpread.ts | 34 +- src/models/TaskSpecPluginSpec.ts | 43 ++- src/models/TaskSpecResources.ts | 35 +- src/models/TaskSpecRestartPolicy.ts | 47 +-- src/models/TaskState.ts | 61 ++-- src/models/TaskStatus.ts | 47 ++- src/models/ThrottleDevice.ts | 35 +- src/models/UnlockKeyResponse.ts | 34 +- src/models/Volume.ts | 68 ++-- src/models/VolumeCreateOptions.ts | 46 ++- src/models/VolumeListResponse.ts | 35 +- src/models/VolumePruneResponse.ts | 35 +- src/models/VolumeUpdateRequest.ts | 32 +- src/models/VolumeUsageData.ts | 39 ++- src/models/index.ts | 31 +- templates/{model => }/licenseInfo.mustache | 2 +- templates/model/index.mustache | 2 + templates/model/model.mustache | 34 +- 237 files changed, 7167 insertions(+), 4385 deletions(-) rename templates/{model => }/licenseInfo.mustache (99%) diff --git a/src/models/Address.ts b/src/models/Address.ts index e2958a6..565ecf9 100644 --- a/src/models/Address.ts +++ b/src/models/Address.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Address represents an IPv4 or IPv6 IP address. */ -export class Address { +export interface Address { /** * IP address. */ - 'Addr'?: string; + Addr?: string; + /** * Mask length of the IP address. */ - 'PrefixLen'?: number; + PrefixLen?: number; } diff --git a/src/models/AuthConfig.ts b/src/models/AuthConfig.ts index 1437bd2..c5f52e3 100644 --- a/src/models/AuthConfig.ts +++ b/src/models/AuthConfig.ts @@ -1,21 +1,32 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class AuthConfig { - 'Username'?: string; - 'Password'?: string; +export interface AuthConfig { + Username?: string; + + Password?: string; + /** - * Email is an optional value associated with the username. > **Deprecated**: This field is deprecated since docker 1.11 (API v1.23) and will be removed in a future release. + * Email is an optional value associated with the username. > **Deprecated**: This field is deprecated since docker 1.11 (API v1.23) and will be removed in a future release. */ - 'Email'?: string; - 'Serveraddress'?: string; + Email?: string; + + Serveraddress?: string; } diff --git a/src/models/BuildCache.ts b/src/models/BuildCache.ts index 151982b..8fc6c91 100644 --- a/src/models/BuildCache.ts +++ b/src/models/BuildCache.ts @@ -1,67 +1,84 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * BuildCache contains information about a build cache record. */ -export class BuildCache { +export interface BuildCache { /** * Unique ID of the build cache record. */ - 'ID'?: string; + ID?: string; + /** - * ID of the parent build cache record. > **Deprecated**: This field is deprecated, and omitted if empty. + * ID of the parent build cache record. > **Deprecated**: This field is deprecated, and omitted if empty. */ - 'Parent'?: string | null; + Parent?: string | null; + /** * List of parent build cache record IDs. */ - 'Parents'?: Array | null; + Parents?: Array | null; + /** * Cache record type. */ - 'Type'?: BuildCacheTypeEnum; + Type?: BuildCacheTypeEnum; + /** * Description of the build-step that produced the build cache. */ - 'Description'?: string; + Description?: string; + /** * Indicates if the build cache is in use. */ - 'InUse'?: boolean; + InUse?: boolean; + /** * Indicates if the build cache is shared. */ - 'Shared'?: boolean; + Shared?: boolean; + /** * Amount of disk space used by the build cache (in bytes). */ - 'Size'?: number; + Size?: number; + /** * Date and time at which the build cache was created in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'CreatedAt'?: string; + CreatedAt?: string; + /** * Date and time at which the build cache was last used in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'LastUsedAt'?: string | null; - 'UsageCount'?: number; -} + LastUsedAt?: string | null; -export enum BuildCacheTypeEnum { - Internal = 'internal', - Frontend = 'frontend', - SourceLocal = 'source.local', - SourceGitCheckout = 'source.git.checkout', - ExecCachemount = 'exec.cachemount', - Regular = 'regular', + UsageCount?: number; } + +export type BuildCacheTypeEnum = + | 'internal' + | 'frontend' + | 'source.local' + | 'source.git.checkout' + | 'exec.cachemount' + | 'regular'; diff --git a/src/models/BuildInfo.ts b/src/models/BuildInfo.ts index 0a126aa..6d35b56 100644 --- a/src/models/BuildInfo.ts +++ b/src/models/BuildInfo.ts @@ -1,24 +1,37 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ErrorDetail } from '../models/ErrorDetail.js'; import { ImageID } from '../models/ImageID.js'; import { ProgressDetail } from '../models/ProgressDetail.js'; -export class BuildInfo { - 'Id'?: string; - 'Stream'?: string; - 'ErrorDetail'?: ErrorDetail; - 'Status'?: string; - 'ProgressDetail'?: ProgressDetail; - 'Aux'?: ImageID; +export interface BuildInfo { + Id?: string; + + Stream?: string; + + ErrorDetail?: ErrorDetail; + + Status?: string; + + ProgressDetail?: ProgressDetail; + + Aux?: ImageID; } diff --git a/src/models/BuildPruneResponse.ts b/src/models/BuildPruneResponse.ts index e233cdf..65fae47 100644 --- a/src/models/BuildPruneResponse.ts +++ b/src/models/BuildPruneResponse.ts @@ -1,19 +1,28 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class BuildPruneResponse { - 'CachesDeleted'?: Array; +export interface BuildPruneResponse { + CachesDeleted?: Array; + /** * Disk space reclaimed in bytes */ - 'SpaceReclaimed'?: number; + SpaceReclaimed?: number; } diff --git a/src/models/ChangeType.ts b/src/models/ChangeType.ts index 28d4d3c..235b78e 100644 --- a/src/models/ChangeType.ts +++ b/src/models/ChangeType.ts @@ -1,20 +1,24 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Kind of change Can be one of: - `0`: Modified (\"C\") - `1`: Added (\"A\") - `2`: Deleted (\"D\") */ -export enum ChangeType { - NUMBER_0 = 0, - NUMBER_1 = 1, - NUMBER_2 = 2, -} +export type ChangeType = 0 | 1 | 2; diff --git a/src/models/ClusterInfo.ts b/src/models/ClusterInfo.ts index 1462ed7..f42ea44 100644 --- a/src/models/ClusterInfo.ts +++ b/src/models/ClusterInfo.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ObjectVersion } from '../models/ObjectVersion.js'; @@ -17,36 +25,45 @@ import { TLSInfo } from '../models/TLSInfo.js'; /** * ClusterInfo represents information about the swarm as is returned by the \"/info\" endpoint. Join-tokens are not included. */ -export class ClusterInfo { +export interface ClusterInfo { /** * The ID of the swarm. */ - 'ID'?: string; - 'Version'?: ObjectVersion; + ID?: string; + + Version?: ObjectVersion; + /** * Date and time at which the swarm was initialised in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'CreatedAt'?: string; + CreatedAt?: string; + /** * Date and time at which the swarm was last updated in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'UpdatedAt'?: string; - 'Spec'?: SwarmSpec; - 'TLSInfo'?: TLSInfo; + UpdatedAt?: string; + + Spec?: SwarmSpec; + + TLSInfo?: TLSInfo; + /** * Whether there is currently a root CA rotation in progress for the swarm */ - 'RootRotationInProgress'?: boolean; + RootRotationInProgress?: boolean; + /** * DataPathPort specifies the data path port number for data traffic. Acceptable port range is 1024 to 49151. If no port is set or is set to 0, the default port (4789) is used. */ - 'DataPathPort'?: number; + DataPathPort?: number; + /** * Default Address Pool specifies default subnet pools for global scope networks. */ - 'DefaultAddrPool'?: Array; + DefaultAddrPool?: Array; + /** * SubnetSize specifies the subnet size of the networks created from the default subnet pool. */ - 'SubnetSize'?: number; + SubnetSize?: number; } diff --git a/src/models/ClusterVolume.ts b/src/models/ClusterVolume.ts index 0a89676..e3a8d06 100644 --- a/src/models/ClusterVolume.ts +++ b/src/models/ClusterVolume.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterVolumeInfo } from '../models/ClusterVolumeInfo.js'; @@ -18,18 +26,24 @@ import { ObjectVersion } from '../models/ObjectVersion.js'; /** * Options and information specific to, and only present on, Swarm CSI cluster volumes. */ -export class ClusterVolume { +export interface ClusterVolume { /** * The Swarm ID of this volume. Because cluster volumes are Swarm objects, they have an ID, unlike non-cluster volumes. This ID can be used to refer to the Volume instead of the name. */ - 'ID'?: string; - 'Version'?: ObjectVersion; - 'CreatedAt'?: string; - 'UpdatedAt'?: string; - 'Spec'?: ClusterVolumeSpec; - 'Info'?: ClusterVolumeInfo; + ID?: string; + + Version?: ObjectVersion; + + CreatedAt?: string; + + UpdatedAt?: string; + + Spec?: ClusterVolumeSpec; + + Info?: ClusterVolumeInfo; + /** * The status of the volume as it pertains to its publishing and use on specific nodes */ - 'PublishStatus'?: Array; + PublishStatus?: Array; } diff --git a/src/models/ClusterVolumeInfo.ts b/src/models/ClusterVolumeInfo.ts index ab53551..a91adfa 100644 --- a/src/models/ClusterVolumeInfo.ts +++ b/src/models/ClusterVolumeInfo.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Information about the global status of the volume. */ -export class ClusterVolumeInfo { +export interface ClusterVolumeInfo { /** * The capacity of the volume in bytes. A value of 0 indicates that the capacity is unknown. */ - 'CapacityBytes'?: number; + CapacityBytes?: number; + /** * A map of strings to strings returned from the storage plugin when the volume is created. */ - 'VolumeContext'?: { [key: string]: string }; + VolumeContext?: { [key: string]: string }; + /** - * The ID of the volume as returned by the CSI storage plugin. This is distinct from the volume\'s ID as provided by Docker. This ID is never used by the user when communicating with Docker to refer to this volume. If the ID is blank, then the Volume has not been successfully created in the plugin yet. + * The ID of the volume as returned by the CSI storage plugin. This is distinct from the volume\'s ID as provided by Docker. This ID is never used by the user when communicating with Docker to refer to this volume. If the ID is blank, then the Volume has not been successfully created in the plugin yet. */ - 'VolumeID'?: string; + VolumeID?: string; + /** * The topology this volume is actually accessible from. */ - 'AccessibleTopology'?: Array<{ [key: string]: string }>; + AccessibleTopology?: Array<{ [key: string]: string }>; } diff --git a/src/models/ClusterVolumePublishStatusInner.ts b/src/models/ClusterVolumePublishStatusInner.ts index a9bbc27..cee5b8e 100644 --- a/src/models/ClusterVolumePublishStatusInner.ts +++ b/src/models/ClusterVolumePublishStatusInner.ts @@ -1,33 +1,42 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ClusterVolumePublishStatusInner { +export interface ClusterVolumePublishStatusInner { /** * The ID of the Swarm node the volume is published on. */ - 'NodeID'?: string; + NodeID?: string; + /** - * The published state of the volume. * `pending-publish` The volume should be published to this node, but the call to the controller plugin to do so has not yet been successfully completed. * `published` The volume is published successfully to the node. * `pending-node-unpublish` The volume should be unpublished from the node, and the manager is awaiting confirmation from the worker that it has done so. * `pending-controller-unpublish` The volume is successfully unpublished from the node, but has not yet been successfully unpublished on the controller. + * The published state of the volume. * `pending-publish` The volume should be published to this node, but the call to the controller plugin to do so has not yet been successfully completed. * `published` The volume is published successfully to the node. * `pending-node-unpublish` The volume should be unpublished from the node, and the manager is awaiting confirmation from the worker that it has done so. * `pending-controller-unpublish` The volume is successfully unpublished from the node, but has not yet been successfully unpublished on the controller. */ - 'State'?: ClusterVolumePublishStatusInnerStateEnum; + State?: ClusterVolumePublishStatusInnerStateEnum; + /** * A map of strings to strings returned by the CSI controller plugin when a volume is published. */ - 'PublishContext'?: { [key: string]: string }; + PublishContext?: { [key: string]: string }; } -export enum ClusterVolumePublishStatusInnerStateEnum { - PendingPublish = 'pending-publish', - Published = 'published', - PendingNodeUnpublish = 'pending-node-unpublish', - PendingControllerUnpublish = 'pending-controller-unpublish', -} +export type ClusterVolumePublishStatusInnerStateEnum = + | 'pending-publish' + | 'published' + | 'pending-node-unpublish' + | 'pending-controller-unpublish'; diff --git a/src/models/ClusterVolumeSpec.ts b/src/models/ClusterVolumeSpec.ts index b6b3873..6b8d2d8 100644 --- a/src/models/ClusterVolumeSpec.ts +++ b/src/models/ClusterVolumeSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterVolumeSpecAccessMode } from '../models/ClusterVolumeSpecAccessMode.js'; @@ -15,10 +23,11 @@ import { ClusterVolumeSpecAccessMode } from '../models/ClusterVolumeSpecAccessMo /** * Cluster-specific options used to create the volume. */ -export class ClusterVolumeSpec { +export interface ClusterVolumeSpec { /** * Group defines the volume group of this volume. Volumes belonging to the same group can be referred to by group name when creating Services. Referring to a volume by group instructs Swarm to treat volumes in that group interchangeably for the purpose of scheduling. Volumes with an empty string for a group technically all belong to the same, emptystring group. */ - 'Group'?: string; - 'AccessMode'?: ClusterVolumeSpecAccessMode; + Group?: string; + + AccessMode?: ClusterVolumeSpecAccessMode; } diff --git a/src/models/ClusterVolumeSpecAccessMode.ts b/src/models/ClusterVolumeSpecAccessMode.ts index 48cc78b..5ec44cf 100644 --- a/src/models/ClusterVolumeSpecAccessMode.ts +++ b/src/models/ClusterVolumeSpecAccessMode.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterVolumeSpecAccessModeAccessibilityRequirements } from '../models/ClusterVolumeSpecAccessModeAccessibilityRequirements.js'; @@ -17,43 +25,44 @@ import { ClusterVolumeSpecAccessModeSecretsInner } from '../models/ClusterVolume /** * Defines how the volume is used by tasks. */ -export class ClusterVolumeSpecAccessMode { +export interface ClusterVolumeSpecAccessMode { /** - * The set of nodes this volume can be used on at one time. - `single` The volume may only be scheduled to one node at a time. - `multi` the volume may be scheduled to any supported number of nodes at a time. + * The set of nodes this volume can be used on at one time. - `single` The volume may only be scheduled to one node at a time. - `multi` the volume may be scheduled to any supported number of nodes at a time. */ - 'Scope'?: ClusterVolumeSpecAccessModeScopeEnum; + Scope?: ClusterVolumeSpecAccessModeScopeEnum; + /** - * The number and way that different tasks can use this volume at one time. - `none` The volume may only be used by one task at a time. - `readonly` The volume may be used by any number of tasks, but they all must mount the volume as readonly - `onewriter` The volume may be used by any number of tasks, but only one may mount it as read/write. - `all` The volume may have any number of readers and writers. + * The number and way that different tasks can use this volume at one time. - `none` The volume may only be used by one task at a time. - `readonly` The volume may be used by any number of tasks, but they all must mount the volume as readonly - `onewriter` The volume may be used by any number of tasks, but only one may mount it as read/write. - `all` The volume may have any number of readers and writers. */ - 'Sharing'?: ClusterVolumeSpecAccessModeSharingEnum; + Sharing?: ClusterVolumeSpecAccessModeSharingEnum; + /** - * Options for using this volume as a Mount-type volume. Either MountVolume or BlockVolume, but not both, must be present. properties: FsType: type: \"string\" description: | Specifies the filesystem type for the mount volume. Optional. MountFlags: type: \"array\" description: | Flags to pass when mounting the volume. Optional. items: type: \"string\" BlockVolume: type: \"object\" description: | Options for using this volume as a Block-type volume. Intentionally empty. + * Options for using this volume as a Mount-type volume. Either MountVolume or BlockVolume, but not both, must be present. properties: FsType: type: \"string\" description: | Specifies the filesystem type for the mount volume. Optional. MountFlags: type: \"array\" description: | Flags to pass when mounting the volume. Optional. items: type: \"string\" BlockVolume: type: \"object\" description: | Options for using this volume as a Block-type volume. Intentionally empty. */ - 'MountVolume'?: any; + MountVolume?: any; + /** * Swarm Secrets that are passed to the CSI storage plugin when operating on this volume. */ - 'Secrets'?: Array; - 'AccessibilityRequirements'?: ClusterVolumeSpecAccessModeAccessibilityRequirements; - 'CapacityRange'?: ClusterVolumeSpecAccessModeCapacityRange; + Secrets?: Array; + + AccessibilityRequirements?: ClusterVolumeSpecAccessModeAccessibilityRequirements; + + CapacityRange?: ClusterVolumeSpecAccessModeCapacityRange; + /** - * The availability of the volume for use in tasks. - `active` The volume is fully available for scheduling on the cluster - `pause` No new workloads should use the volume, but existing workloads are not stopped. - `drain` All workloads using this volume should be stopped and rescheduled, and no new ones should be started. + * The availability of the volume for use in tasks. - `active` The volume is fully available for scheduling on the cluster - `pause` No new workloads should use the volume, but existing workloads are not stopped. - `drain` All workloads using this volume should be stopped and rescheduled, and no new ones should be started. */ - 'Availability'?: ClusterVolumeSpecAccessModeAvailabilityEnum; + Availability?: ClusterVolumeSpecAccessModeAvailabilityEnum; } -export enum ClusterVolumeSpecAccessModeScopeEnum { - Single = 'single', - Multi = 'multi', -} -export enum ClusterVolumeSpecAccessModeSharingEnum { - None = 'none', - Readonly = 'readonly', - Onewriter = 'onewriter', - All = 'all', -} -export enum ClusterVolumeSpecAccessModeAvailabilityEnum { - Active = 'active', - Pause = 'pause', - Drain = 'drain', -} +export type ClusterVolumeSpecAccessModeScopeEnum = 'single' | 'multi'; +export type ClusterVolumeSpecAccessModeSharingEnum = + | 'none' + | 'readonly' + | 'onewriter' + | 'all'; +export type ClusterVolumeSpecAccessModeAvailabilityEnum = + | 'active' + | 'pause' + | 'drain'; diff --git a/src/models/ClusterVolumeSpecAccessModeAccessibilityRequirements.ts b/src/models/ClusterVolumeSpecAccessModeAccessibilityRequirements.ts index a98fea5..b20ddc2 100644 --- a/src/models/ClusterVolumeSpecAccessModeAccessibilityRequirements.ts +++ b/src/models/ClusterVolumeSpecAccessModeAccessibilityRequirements.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Requirements for the accessible topology of the volume. These fields are optional. For an in-depth description of what these fields mean, see the CSI specification. */ -export class ClusterVolumeSpecAccessModeAccessibilityRequirements { +export interface ClusterVolumeSpecAccessModeAccessibilityRequirements { /** * A list of required topologies, at least one of which the volume must be accessible from. */ - 'Requisite'?: Array<{ [key: string]: string }>; + Requisite?: Array<{ [key: string]: string }>; + /** * A list of topologies that the volume should attempt to be provisioned in. */ - 'Preferred'?: Array<{ [key: string]: string }>; + Preferred?: Array<{ [key: string]: string }>; } diff --git a/src/models/ClusterVolumeSpecAccessModeCapacityRange.ts b/src/models/ClusterVolumeSpecAccessModeCapacityRange.ts index 49b4e59..4c5448c 100644 --- a/src/models/ClusterVolumeSpecAccessModeCapacityRange.ts +++ b/src/models/ClusterVolumeSpecAccessModeCapacityRange.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The desired capacity that the volume should be created with. If empty, the plugin will decide the capacity. */ -export class ClusterVolumeSpecAccessModeCapacityRange { +export interface ClusterVolumeSpecAccessModeCapacityRange { /** * The volume must be at least this big. The value of 0 indicates an unspecified minimum */ - 'RequiredBytes'?: number; + RequiredBytes?: number; + /** * The volume must not be bigger than this. The value of 0 indicates an unspecified maximum. */ - 'LimitBytes'?: number; + LimitBytes?: number; } diff --git a/src/models/ClusterVolumeSpecAccessModeSecretsInner.ts b/src/models/ClusterVolumeSpecAccessModeSecretsInner.ts index 3450d03..916e255 100644 --- a/src/models/ClusterVolumeSpecAccessModeSecretsInner.ts +++ b/src/models/ClusterVolumeSpecAccessModeSecretsInner.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * One cluster volume secret entry. Defines a key-value pair that is passed to the plugin. */ -export class ClusterVolumeSpecAccessModeSecretsInner { +export interface ClusterVolumeSpecAccessModeSecretsInner { /** * Key is the name of the key of the key-value pair passed to the plugin. */ - 'Key'?: string; + Key?: string; + /** * Secret is the swarm Secret object from which to read data. This can be a Secret name or ID. The Secret data is retrieved by swarm and used as the value of the key-value pair passed to the plugin. */ - 'Secret'?: string; + Secret?: string; } diff --git a/src/models/Commit.ts b/src/models/Commit.ts index 1eaa61e..6bb030d 100644 --- a/src/models/Commit.ts +++ b/src/models/Commit.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Commit holds the Git-commit (SHA1) that a binary was built from, as reported in the version-string of external tools, such as `containerd`, or `runC`. */ -export class Commit { +export interface Commit { /** * Actual commit ID of external tool. */ - 'ID'?: string; + ID?: string; } diff --git a/src/models/Config.ts b/src/models/Config.ts index 5131235..94328c7 100644 --- a/src/models/Config.ts +++ b/src/models/Config.ts @@ -1,22 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ConfigSpec } from '../models/ConfigSpec.js'; import { ObjectVersion } from '../models/ObjectVersion.js'; -export class Config { - 'ID'?: string; - 'Version'?: ObjectVersion; - 'CreatedAt'?: string; - 'UpdatedAt'?: string; - 'Spec'?: ConfigSpec; +export interface Config { + ID?: string; + + Version?: ObjectVersion; + + CreatedAt?: string; + + UpdatedAt?: string; + + Spec?: ConfigSpec; } diff --git a/src/models/ConfigCreateRequest.ts b/src/models/ConfigCreateRequest.ts index ba02bee..691b4e3 100644 --- a/src/models/ConfigCreateRequest.ts +++ b/src/models/ConfigCreateRequest.ts @@ -1,29 +1,40 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Driver } from '../models/Driver.js'; -export class ConfigCreateRequest { +export interface ConfigCreateRequest { /** * User-defined name of the config. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Data is the data to store as a config, formatted as a Base64-url-safe-encoded ([RFC 4648](https://tools.ietf.org/html/rfc4648#section-5)) string. The maximum allowed size is 1000KB, as defined in [MaxConfigSize](https://pkg.go.dev/github.com/moby/swarmkit/v2@v2.0.0-20250103191802-8c1959736554/manager/controlapi#MaxConfigSize). */ - 'Data'?: string; - 'Templating'?: Driver; + Data?: string; + + Templating?: Driver; } diff --git a/src/models/ConfigReference.ts b/src/models/ConfigReference.ts index 9278274..2cae445 100644 --- a/src/models/ConfigReference.ts +++ b/src/models/ConfigReference.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The config-only network source to provide the configuration for this network. */ -export class ConfigReference { +export interface ConfigReference { /** - * The name of the config-only network that provides the network\'s configuration. The specified network must be an existing config-only network. Only network names are allowed, not network IDs. + * The name of the config-only network that provides the network\'s configuration. The specified network must be an existing config-only network. Only network names are allowed, not network IDs. */ - 'Network'?: string; + Network?: string; } diff --git a/src/models/ConfigSpec.ts b/src/models/ConfigSpec.ts index 520de27..9c2c6e3 100644 --- a/src/models/ConfigSpec.ts +++ b/src/models/ConfigSpec.ts @@ -1,29 +1,40 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Driver } from '../models/Driver.js'; -export class ConfigSpec { +export interface ConfigSpec { /** * User-defined name of the config. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Data is the data to store as a config, formatted as a Base64-url-safe-encoded ([RFC 4648](https://tools.ietf.org/html/rfc4648#section-5)) string. The maximum allowed size is 1000KB, as defined in [MaxConfigSize](https://pkg.go.dev/github.com/moby/swarmkit/v2@v2.0.0-20250103191802-8c1959736554/manager/controlapi#MaxConfigSize). */ - 'Data'?: string; - 'Templating'?: Driver; + Data?: string; + + Templating?: Driver; } diff --git a/src/models/ContainerBlkioStatEntry.ts b/src/models/ContainerBlkioStatEntry.ts index f9f1a84..0f2829a 100644 --- a/src/models/ContainerBlkioStatEntry.ts +++ b/src/models/ContainerBlkioStatEntry.ts @@ -1,21 +1,32 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Blkio stats entry. This type is Linux-specific and omitted for Windows containers. */ -export class ContainerBlkioStatEntry { - 'Major'?: number; - 'Minor'?: number; - 'Op'?: string; - 'Value'?: number; +export interface ContainerBlkioStatEntry { + Major?: number; + + Minor?: number; + + Op?: string; + + Value?: number; } diff --git a/src/models/ContainerBlkioStats.ts b/src/models/ContainerBlkioStats.ts index 57cdbcd..5c28c98 100644 --- a/src/models/ContainerBlkioStats.ts +++ b/src/models/ContainerBlkioStats.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerBlkioStatEntry } from '../models/ContainerBlkioStatEntry.js'; @@ -15,34 +23,41 @@ import { ContainerBlkioStatEntry } from '../models/ContainerBlkioStatEntry.js'; /** * BlkioStats stores all IO service stats for data read and write. This type is Linux-specific and holds many fields that are specific to cgroups v1. On a cgroup v2 host, all fields other than `io_service_bytes_recursive` are omitted or `null`. This type is only populated on Linux and omitted for Windows containers. */ -export class ContainerBlkioStats { - 'IoServiceBytesRecursive'?: Array; +export interface ContainerBlkioStats { + IoServiceBytesRecursive?: Array; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'IoServicedRecursive'?: Array | null; + IoServicedRecursive?: Array | null; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'IoQueueRecursive'?: Array | null; + IoQueueRecursive?: Array | null; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'IoServiceTimeRecursive'?: Array | null; + IoServiceTimeRecursive?: Array | null; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'IoWaitTimeRecursive'?: Array | null; + IoWaitTimeRecursive?: Array | null; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'IoMergedRecursive'?: Array | null; + IoMergedRecursive?: Array | null; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'IoTimeRecursive'?: Array | null; + IoTimeRecursive?: Array | null; + /** - * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. + * This field is only available when using Linux containers with cgroups v1. It is omitted or `null` when using cgroups v2. */ - 'SectorsRecursive'?: Array | null; + SectorsRecursive?: Array | null; } diff --git a/src/models/ContainerCPUStats.ts b/src/models/ContainerCPUStats.ts index e0ce8a3..3cfa6c3 100644 --- a/src/models/ContainerCPUStats.ts +++ b/src/models/ContainerCPUStats.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerCPUUsage } from '../models/ContainerCPUUsage.js'; @@ -16,15 +24,18 @@ import { ContainerThrottlingData } from '../models/ContainerThrottlingData.js'; /** * CPU related info of the container */ -export class ContainerCPUStats { - 'CpuUsage'?: ContainerCPUUsage | null; +export interface ContainerCPUStats { + CpuUsage?: ContainerCPUUsage | null; + /** * System Usage. This field is Linux-specific and omitted for Windows containers. */ - 'SystemCpuUsage'?: number | null; + SystemCpuUsage?: number | null; + /** * Number of online CPUs. This field is Linux-specific and omitted for Windows containers. */ - 'OnlineCpus'?: number | null; - 'ThrottlingData'?: ContainerThrottlingData | null; + OnlineCpus?: number | null; + + ThrottlingData?: ContainerThrottlingData | null; } diff --git a/src/models/ContainerCPUUsage.ts b/src/models/ContainerCPUUsage.ts index 97b130a..39e09e2 100644 --- a/src/models/ContainerCPUUsage.ts +++ b/src/models/ContainerCPUUsage.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * All CPU stats aggregated since container inception. */ -export class ContainerCPUUsage { +export interface ContainerCPUUsage { /** - * Total CPU time consumed in nanoseconds (Linux) or 100\'s of nanoseconds (Windows). + * Total CPU time consumed in nanoseconds (Linux) or 100\'s of nanoseconds (Windows). */ - 'TotalUsage'?: number; + TotalUsage?: number; + /** * Total CPU time (in nanoseconds) consumed per core (Linux). This field is Linux-specific when using cgroups v1. It is omitted when using cgroups v2 and Windows containers. */ - 'PercpuUsage'?: Array | null; + PercpuUsage?: Array | null; + /** - * Time (in nanoseconds) spent by tasks of the cgroup in kernel mode (Linux), or time spent (in 100\'s of nanoseconds) by all container processes in kernel mode (Windows). Not populated for Windows containers using Hyper-V isolation. + * Time (in nanoseconds) spent by tasks of the cgroup in kernel mode (Linux), or time spent (in 100\'s of nanoseconds) by all container processes in kernel mode (Windows). Not populated for Windows containers using Hyper-V isolation. */ - 'UsageInKernelmode'?: number; + UsageInKernelmode?: number; + /** - * Time (in nanoseconds) spent by tasks of the cgroup in user mode (Linux), or time spent (in 100\'s of nanoseconds) by all container processes in kernel mode (Windows). Not populated for Windows containers using Hyper-V isolation. + * Time (in nanoseconds) spent by tasks of the cgroup in user mode (Linux), or time spent (in 100\'s of nanoseconds) by all container processes in kernel mode (Windows). Not populated for Windows containers using Hyper-V isolation. */ - 'UsageInUsermode'?: number; + UsageInUsermode?: number; } diff --git a/src/models/ContainerConfig.ts b/src/models/ContainerConfig.ts index 772ebd9..2223ab7 100644 --- a/src/models/ContainerConfig.ts +++ b/src/models/ContainerConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { HealthConfig } from '../models/HealthConfig.js'; @@ -15,102 +23,126 @@ import { HealthConfig } from '../models/HealthConfig.js'; /** * Configuration for a container that is portable between hosts. */ -export class ContainerConfig { +export interface ContainerConfig { /** * The hostname to use for the container, as a valid RFC 1123 hostname. */ - 'Hostname'?: string; + Hostname?: string; + /** * The domain name to use for the container. */ - 'Domainname'?: string; + Domainname?: string; + /** - * Commands run as this user inside the container. If omitted, commands run as the user specified in the image the container was started from. Can be either user-name or UID, and optional group-name or GID, separated by a colon (`[<:group-name|GID>]`). + * Commands run as this user inside the container. If omitted, commands run as the user specified in the image the container was started from. Can be either user-name or UID, and optional group-name or GID, separated by a colon (`<user-name|UID>[<:group-name|GID>]`). */ - 'User'?: string; + User?: string; + /** - * Whether to attach to `stdin`. + * Whether to attach to `stdin`. */ - 'AttachStdin'?: boolean; + AttachStdin?: boolean; + /** - * Whether to attach to `stdout`. + * Whether to attach to `stdout`. */ - 'AttachStdout'?: boolean; + AttachStdout?: boolean; + /** - * Whether to attach to `stderr`. + * Whether to attach to `stderr`. */ - 'AttachStderr'?: boolean; + AttachStderr?: boolean; + /** - * An object mapping ports to an empty object in the form: `{\"/\": {}}` + * An object mapping ports to an empty object in the form: `{\"<port>/<tcp|udp|sctp>\": {}}` */ - 'ExposedPorts'?: { [key: string]: any } | null; + ExposedPorts?: { [key: string]: any } | null; + /** - * Attach standard streams to a TTY, including `stdin` if it is not closed. + * Attach standard streams to a TTY, including `stdin` if it is not closed. */ - 'Tty'?: boolean; + Tty?: boolean; + /** - * Open `stdin` + * Open `stdin` */ - 'OpenStdin'?: boolean; + OpenStdin?: boolean; + /** - * Close `stdin` after one attached client disconnects + * Close `stdin` after one attached client disconnects */ - 'StdinOnce'?: boolean; + StdinOnce?: boolean; + /** - * A list of environment variables to set inside the container in the form `[\"VAR=value\", ...]`. A variable without `=` is removed from the environment, rather than to have an empty value. + * A list of environment variables to set inside the container in the form `[\"VAR=value\", ...]`. A variable without `=` is removed from the environment, rather than to have an empty value. */ - 'Env'?: Array; + Env?: Array; + /** * Command to run specified as a string or an array of strings. */ - 'Cmd'?: Array; - 'Healthcheck'?: HealthConfig; + Cmd?: Array; + + Healthcheck?: HealthConfig; + /** * Command is already escaped (Windows only) */ - 'ArgsEscaped'?: boolean | null; + ArgsEscaped?: boolean | null; + /** * The name (or reference) of the image to use when creating the container, or which was used when the container was created. */ - 'Image'?: string; + Image?: string; + /** * An object mapping mount point paths inside the container to empty objects. */ - 'Volumes'?: { [key: string]: any }; + Volumes?: { [key: string]: any }; + /** * The working directory for commands to run in. */ - 'WorkingDir'?: string; + WorkingDir?: string; + /** - * The entry point for the container as a string or an array of strings. If the array consists of exactly one empty string (`[\"\"]`) then the entry point is reset to system default (i.e., the entry point used by docker when there is no `ENTRYPOINT` instruction in the `Dockerfile`). + * The entry point for the container as a string or an array of strings. If the array consists of exactly one empty string (`[\"\"]`) then the entry point is reset to system default (i.e., the entry point used by docker when there is no `ENTRYPOINT` instruction in the `Dockerfile`). */ - 'Entrypoint'?: Array; + Entrypoint?: Array; + /** * Disable networking for the container. */ - 'NetworkDisabled'?: boolean | null; + NetworkDisabled?: boolean | null; + /** * MAC address of the container. Deprecated: this field is deprecated in API v1.44 and up. Use EndpointSettings.MacAddress instead. */ - 'MacAddress'?: string | null; + MacAddress?: string | null; + /** - * `ONBUILD` metadata that were defined in the image\'s `Dockerfile`. + * `ONBUILD` metadata that were defined in the image\'s `Dockerfile`. */ - 'OnBuild'?: Array | null; + OnBuild?: Array | null; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Signal to stop a container as a string or unsigned integer. */ - 'StopSignal'?: string | null; + StopSignal?: string | null; + /** * Timeout to stop a container in seconds. */ - 'StopTimeout'?: number | null; + StopTimeout?: number | null; + /** - * Shell for when `RUN`, `CMD`, and `ENTRYPOINT` uses a shell. + * Shell for when `RUN`, `CMD`, and `ENTRYPOINT` uses a shell. */ - 'Shell'?: Array | null; + Shell?: Array | null; } diff --git a/src/models/ContainerCreateRequest.ts b/src/models/ContainerCreateRequest.ts index 579e3c6..391cb9a 100644 --- a/src/models/ContainerCreateRequest.ts +++ b/src/models/ContainerCreateRequest.ts @@ -1,117 +1,151 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { HealthConfig } from '../models/HealthConfig.js'; import { HostConfig } from '../models/HostConfig.js'; import { NetworkingConfig } from '../models/NetworkingConfig.js'; -export class ContainerCreateRequest { +export interface ContainerCreateRequest { /** * The hostname to use for the container, as a valid RFC 1123 hostname. */ - 'Hostname'?: string; + Hostname?: string; + /** * The domain name to use for the container. */ - 'Domainname'?: string; + Domainname?: string; + /** - * Commands run as this user inside the container. If omitted, commands run as the user specified in the image the container was started from. Can be either user-name or UID, and optional group-name or GID, separated by a colon (`[<:group-name|GID>]`). + * Commands run as this user inside the container. If omitted, commands run as the user specified in the image the container was started from. Can be either user-name or UID, and optional group-name or GID, separated by a colon (`<user-name|UID>[<:group-name|GID>]`). */ - 'User'?: string; + User?: string; + /** - * Whether to attach to `stdin`. + * Whether to attach to `stdin`. */ - 'AttachStdin'?: boolean; + AttachStdin?: boolean; + /** - * Whether to attach to `stdout`. + * Whether to attach to `stdout`. */ - 'AttachStdout'?: boolean; + AttachStdout?: boolean; + /** - * Whether to attach to `stderr`. + * Whether to attach to `stderr`. */ - 'AttachStderr'?: boolean; + AttachStderr?: boolean; + /** - * An object mapping ports to an empty object in the form: `{\"/\": {}}` + * An object mapping ports to an empty object in the form: `{\"<port>/<tcp|udp|sctp>\": {}}` */ - 'ExposedPorts'?: { [key: string]: any } | null; + ExposedPorts?: { [key: string]: any } | null; + /** - * Attach standard streams to a TTY, including `stdin` if it is not closed. + * Attach standard streams to a TTY, including `stdin` if it is not closed. */ - 'Tty'?: boolean; + Tty?: boolean; + /** - * Open `stdin` + * Open `stdin` */ - 'OpenStdin'?: boolean; + OpenStdin?: boolean; + /** - * Close `stdin` after one attached client disconnects + * Close `stdin` after one attached client disconnects */ - 'StdinOnce'?: boolean; + StdinOnce?: boolean; + /** - * A list of environment variables to set inside the container in the form `[\"VAR=value\", ...]`. A variable without `=` is removed from the environment, rather than to have an empty value. + * A list of environment variables to set inside the container in the form `[\"VAR=value\", ...]`. A variable without `=` is removed from the environment, rather than to have an empty value. */ - 'Env'?: Array; + Env?: Array; + /** * Command to run specified as a string or an array of strings. */ - 'Cmd'?: Array; - 'Healthcheck'?: HealthConfig; + Cmd?: Array; + + Healthcheck?: HealthConfig; + /** * Command is already escaped (Windows only) */ - 'ArgsEscaped'?: boolean | null; + ArgsEscaped?: boolean | null; + /** * The name (or reference) of the image to use when creating the container, or which was used when the container was created. */ - 'Image'?: string; + Image?: string; + /** * An object mapping mount point paths inside the container to empty objects. */ - 'Volumes'?: { [key: string]: any }; + Volumes?: { [key: string]: any }; + /** * The working directory for commands to run in. */ - 'WorkingDir'?: string; + WorkingDir?: string; + /** - * The entry point for the container as a string or an array of strings. If the array consists of exactly one empty string (`[\"\"]`) then the entry point is reset to system default (i.e., the entry point used by docker when there is no `ENTRYPOINT` instruction in the `Dockerfile`). + * The entry point for the container as a string or an array of strings. If the array consists of exactly one empty string (`[\"\"]`) then the entry point is reset to system default (i.e., the entry point used by docker when there is no `ENTRYPOINT` instruction in the `Dockerfile`). */ - 'Entrypoint'?: Array; + Entrypoint?: Array; + /** * Disable networking for the container. */ - 'NetworkDisabled'?: boolean | null; + NetworkDisabled?: boolean | null; + /** * MAC address of the container. Deprecated: this field is deprecated in API v1.44 and up. Use EndpointSettings.MacAddress instead. */ - 'MacAddress'?: string | null; + MacAddress?: string | null; + /** - * `ONBUILD` metadata that were defined in the image\'s `Dockerfile`. + * `ONBUILD` metadata that were defined in the image\'s `Dockerfile`. */ - 'OnBuild'?: Array | null; + OnBuild?: Array | null; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Signal to stop a container as a string or unsigned integer. */ - 'StopSignal'?: string | null; + StopSignal?: string | null; + /** * Timeout to stop a container in seconds. */ - 'StopTimeout'?: number | null; + StopTimeout?: number | null; + /** - * Shell for when `RUN`, `CMD`, and `ENTRYPOINT` uses a shell. + * Shell for when `RUN`, `CMD`, and `ENTRYPOINT` uses a shell. */ - 'Shell'?: Array | null; - 'HostConfig'?: HostConfig; - 'NetworkingConfig'?: NetworkingConfig; + Shell?: Array | null; + + HostConfig?: HostConfig; + + NetworkingConfig?: NetworkingConfig; } diff --git a/src/models/ContainerCreateResponse.ts b/src/models/ContainerCreateResponse.ts index 270da02..0d519a9 100644 --- a/src/models/ContainerCreateResponse.ts +++ b/src/models/ContainerCreateResponse.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * OK response to ContainerCreate operation */ -export class ContainerCreateResponse { +export interface ContainerCreateResponse { /** * The ID of the created container */ - 'Id': string; + Id: string; + /** * Warnings encountered when creating the container */ - 'Warnings': Array; + Warnings: Array; } diff --git a/src/models/ContainerInspectResponse.ts b/src/models/ContainerInspectResponse.ts index 765e145..b8abe06 100644 --- a/src/models/ContainerInspectResponse.ts +++ b/src/models/ContainerInspectResponse.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerConfig } from '../models/ContainerConfig.js'; @@ -18,91 +26,116 @@ import { MountPoint } from '../models/MountPoint.js'; import { NetworkSettings } from '../models/NetworkSettings.js'; import { OCIDescriptor } from '../models/OCIDescriptor.js'; -export class ContainerInspectResponse { +export interface ContainerInspectResponse { /** * The ID of this container as a 128-bit (64-character) hexadecimal string (32 bytes). */ - 'Id'?: string; + Id?: string; + /** * Date and time at which the container was created, formatted in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'Created'?: string | null; + Created?: string | null; + /** * The path to the command being run */ - 'Path'?: string; + Path?: string; + /** * The arguments to the command being run */ - 'Args'?: Array; - 'State'?: ContainerState | null; + Args?: Array; + + State?: ContainerState | null; + /** * The ID (digest) of the image that this container was created from. */ - 'Image'?: string; + Image?: string; + /** - * Location of the `/etc/resolv.conf` generated for the container on the host. This file is managed through the docker daemon, and should not be accessed or modified by other tools. + * Location of the `/etc/resolv.conf` generated for the container on the host. This file is managed through the docker daemon, and should not be accessed or modified by other tools. */ - 'ResolvConfPath'?: string; + ResolvConfPath?: string; + /** - * Location of the `/etc/hostname` generated for the container on the host. This file is managed through the docker daemon, and should not be accessed or modified by other tools. + * Location of the `/etc/hostname` generated for the container on the host. This file is managed through the docker daemon, and should not be accessed or modified by other tools. */ - 'HostnamePath'?: string; + HostnamePath?: string; + /** - * Location of the `/etc/hosts` generated for the container on the host. This file is managed through the docker daemon, and should not be accessed or modified by other tools. + * Location of the `/etc/hosts` generated for the container on the host. This file is managed through the docker daemon, and should not be accessed or modified by other tools. */ - 'HostsPath'?: string; + HostsPath?: string; + /** - * Location of the file used to buffer the container\'s logs. Depending on the logging-driver used for the container, this field may be omitted. This file is managed through the docker daemon, and should not be accessed or modified by other tools. + * Location of the file used to buffer the container\'s logs. Depending on the logging-driver used for the container, this field may be omitted. This file is managed through the docker daemon, and should not be accessed or modified by other tools. */ - 'LogPath'?: string | null; + LogPath?: string | null; + /** - * The name associated with this container. For historic reasons, the name may be prefixed with a forward-slash (`/`). + * The name associated with this container. For historic reasons, the name may be prefixed with a forward-slash (`/`). */ - 'Name'?: string; + Name?: string; + /** * Number of times the container was restarted since it was created, or since daemon was started. */ - 'RestartCount'?: number; + RestartCount?: number; + /** - * The storage-driver used for the container\'s filesystem (graph-driver or snapshotter). + * The storage-driver used for the container\'s filesystem (graph-driver or snapshotter). */ - 'Driver'?: string; + Driver?: string; + /** - * The platform (operating system) for which the container was created. This field was introduced for the experimental \"LCOW\" (Linux Containers On Windows) features, which has been removed. In most cases, this field is equal to the host\'s operating system (`linux` or `windows`). + * The platform (operating system) for which the container was created. This field was introduced for the experimental \"LCOW\" (Linux Containers On Windows) features, which has been removed. In most cases, this field is equal to the host\'s operating system (`linux` or `windows`). */ - 'Platform'?: string; - 'ImageManifestDescriptor'?: OCIDescriptor; + Platform?: string; + + ImageManifestDescriptor?: OCIDescriptor; + /** * SELinux mount label set for the container. */ - 'MountLabel'?: string; + MountLabel?: string; + /** * SELinux process label set for the container. */ - 'ProcessLabel'?: string; + ProcessLabel?: string; + /** * The AppArmor profile set for the container. */ - 'AppArmorProfile'?: string; + AppArmorProfile?: string; + /** * IDs of exec instances that are running in the container. */ - 'ExecIDs'?: Array | null; - 'HostConfig'?: HostConfig; - 'GraphDriver'?: DriverData; + ExecIDs?: Array | null; + + HostConfig?: HostConfig; + + GraphDriver?: DriverData; + /** * The size of files that have been created or changed by this container. This field is omitted by default, and only set when size is requested in the API request. */ - 'SizeRw'?: number | null; + SizeRw?: number | null; + /** * The total size of all files in the read-only layers from the image that the container uses. These layers can be shared between containers. This field is omitted by default, and only set when size is requested in the API request. */ - 'SizeRootFs'?: number | null; + SizeRootFs?: number | null; + /** * List of mounts used by the container. */ - 'Mounts'?: Array; - 'Config'?: ContainerConfig; - 'NetworkSettings'?: NetworkSettings; + Mounts?: Array; + + Config?: ContainerConfig; + + NetworkSettings?: NetworkSettings; } diff --git a/src/models/ContainerMemoryStats.ts b/src/models/ContainerMemoryStats.ts index a0269df..4c625b3 100644 --- a/src/models/ContainerMemoryStats.ts +++ b/src/models/ContainerMemoryStats.ts @@ -1,49 +1,64 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Aggregates all memory stats since container inception on Linux. Windows returns stats for commit and private working set only. */ -export class ContainerMemoryStats { +export interface ContainerMemoryStats { /** - * Current `res_counter` usage for memory. This field is Linux-specific and omitted for Windows containers. + * Current `res_counter` usage for memory. This field is Linux-specific and omitted for Windows containers. */ - 'Usage'?: number | null; + Usage?: number | null; + /** * Maximum usage ever recorded. This field is Linux-specific and only supported on cgroups v1. It is omitted when using cgroups v2 and for Windows containers. */ - 'MaxUsage'?: number | null; + MaxUsage?: number | null; + /** * All the stats exported via memory.stat. when using cgroups v2. This field is Linux-specific and omitted for Windows containers. */ - 'Stats'?: { [key: string]: number | null }; + Stats?: { [key: string]: number | null }; + /** * Number of times memory usage hits limits. This field is Linux-specific and only supported on cgroups v1. It is omitted when using cgroups v2 and for Windows containers. */ - 'Failcnt'?: number | null; + Failcnt?: number | null; + /** * This field is Linux-specific and omitted for Windows containers. */ - 'Limit'?: number | null; + Limit?: number | null; + /** * Committed bytes. This field is Windows-specific and omitted for Linux containers. */ - 'Commitbytes'?: number | null; + Commitbytes?: number | null; + /** * Peak committed bytes. This field is Windows-specific and omitted for Linux containers. */ - 'Commitpeakbytes'?: number | null; + Commitpeakbytes?: number | null; + /** * Private working set. This field is Windows-specific and omitted for Linux containers. */ - 'Privateworkingset'?: number | null; + Privateworkingset?: number | null; } diff --git a/src/models/ContainerNetworkStats.ts b/src/models/ContainerNetworkStats.ts index 2919e06..5708ce1 100644 --- a/src/models/ContainerNetworkStats.ts +++ b/src/models/ContainerNetworkStats.ts @@ -1,57 +1,74 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Aggregates the network stats of one container */ -export class ContainerNetworkStats { +export interface ContainerNetworkStats { /** * Bytes received. Windows and Linux. */ - 'RxBytes'?: number; + RxBytes?: number; + /** * Packets received. Windows and Linux. */ - 'RxPackets'?: number; + RxPackets?: number; + /** * Received errors. Not used on Windows. This field is Linux-specific and always zero for Windows containers. */ - 'RxErrors'?: number; + RxErrors?: number; + /** * Incoming packets dropped. Windows and Linux. */ - 'RxDropped'?: number; + RxDropped?: number; + /** * Bytes sent. Windows and Linux. */ - 'TxBytes'?: number; + TxBytes?: number; + /** * Packets sent. Windows and Linux. */ - 'TxPackets'?: number; + TxPackets?: number; + /** * Sent errors. Not used on Windows. This field is Linux-specific and always zero for Windows containers. */ - 'TxErrors'?: number; + TxErrors?: number; + /** * Outgoing packets dropped. Windows and Linux. */ - 'TxDropped'?: number; + TxDropped?: number; + /** * Endpoint ID. Not used on Linux. This field is Windows-specific and omitted for Linux containers. */ - 'EndpointId'?: string | null; + EndpointId?: string | null; + /** * Instance ID. Not used on Linux. This field is Windows-specific and omitted for Linux containers. */ - 'InstanceId'?: string | null; + InstanceId?: string | null; } diff --git a/src/models/ContainerPidsStats.ts b/src/models/ContainerPidsStats.ts index 8615e9c..2ee4a49 100644 --- a/src/models/ContainerPidsStats.ts +++ b/src/models/ContainerPidsStats.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * PidsStats contains Linux-specific stats of a container\'s process-IDs (PIDs). This type is Linux-specific and omitted for Windows containers. */ -export class ContainerPidsStats { +export interface ContainerPidsStats { /** * Current is the number of PIDs in the cgroup. */ - 'Current'?: number | null; + Current?: number | null; + /** - * Limit is the hard limit on the number of pids in the cgroup. A \"Limit\" of 0 means that there is no limit. + * Limit is the hard limit on the number of pids in the cgroup. A \"Limit\" of 0 means that there is no limit. */ - 'Limit'?: number | null; + Limit?: number | null; } diff --git a/src/models/ContainerPruneResponse.ts b/src/models/ContainerPruneResponse.ts index a491102..a01bf6f 100644 --- a/src/models/ContainerPruneResponse.ts +++ b/src/models/ContainerPruneResponse.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ContainerPruneResponse { +export interface ContainerPruneResponse { /** * Container IDs that were deleted */ - 'ContainersDeleted'?: Array; + ContainersDeleted?: Array; + /** * Disk space reclaimed in bytes */ - 'SpaceReclaimed'?: number; + SpaceReclaimed?: number; } diff --git a/src/models/ContainerState.ts b/src/models/ContainerState.ts index aa91ff7..4957bda 100644 --- a/src/models/ContainerState.ts +++ b/src/models/ContainerState.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Health } from '../models/Health.js'; @@ -15,54 +23,64 @@ import { Health } from '../models/Health.js'; /** * ContainerState stores container\'s running state. It\'s part of ContainerJSONBase and will be returned by the \"inspect\" command. */ -export class ContainerState { +export interface ContainerState { /** - * String representation of the container state. Can be one of \"created\", \"running\", \"paused\", \"restarting\", \"removing\", \"exited\", or \"dead\". + * String representation of the container state. Can be one of \"created\", \"running\", \"paused\", \"restarting\", \"removing\", \"exited\", or \"dead\". */ - 'Status'?: ContainerStateStatusEnum; + Status?: ContainerStateStatusEnum; + /** - * Whether this container is running. Note that a running container can be _paused_. The `Running` and `Paused` booleans are not mutually exclusive: When pausing a container (on Linux), the freezer cgroup is used to suspend all processes in the container. Freezing the process requires the process to be running. As a result, paused containers are both `Running` _and_ `Paused`. Use the `Status` field instead to determine if a container\'s state is \"running\". + * Whether this container is running. Note that a running container can be _paused_. The `Running` and `Paused` booleans are not mutually exclusive: When pausing a container (on Linux), the freezer cgroup is used to suspend all processes in the container. Freezing the process requires the process to be running. As a result, paused containers are both `Running` _and_ `Paused`. Use the `Status` field instead to determine if a container\'s state is \"running\". */ - 'Running'?: boolean; + Running?: boolean; + /** * Whether this container is paused. */ - 'Paused'?: boolean; + Paused?: boolean; + /** * Whether this container is restarting. */ - 'Restarting'?: boolean; + Restarting?: boolean; + /** * Whether a process within this container has been killed because it ran out of memory since the container was last started. */ - 'OOMKilled'?: boolean; - 'Dead'?: boolean; + OOMKilled?: boolean; + + Dead?: boolean; + /** * The process ID of this container */ - 'Pid'?: number; + Pid?: number; + /** * The last exit code of this container */ - 'ExitCode'?: number; - 'Error'?: string; + ExitCode?: number; + + Error?: string; + /** * The time when this container was last started. */ - 'StartedAt'?: string; + StartedAt?: string; + /** * The time when this container last exited. */ - 'FinishedAt'?: string; - 'Health'?: Health | null; -} + FinishedAt?: string; -export enum ContainerStateStatusEnum { - Created = 'created', - Running = 'running', - Paused = 'paused', - Restarting = 'restarting', - Removing = 'removing', - Exited = 'exited', - Dead = 'dead', + Health?: Health | null; } + +export type ContainerStateStatusEnum = + | 'created' + | 'running' + | 'paused' + | 'restarting' + | 'removing' + | 'exited' + | 'dead'; diff --git a/src/models/ContainerStatsResponse.ts b/src/models/ContainerStatsResponse.ts index fa4f0fb..ff97da9 100644 --- a/src/models/ContainerStatsResponse.ts +++ b/src/models/ContainerStatsResponse.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerBlkioStats } from '../models/ContainerBlkioStats.js'; @@ -19,35 +27,46 @@ import { ContainerStorageStats } from '../models/ContainerStorageStats.js'; /** * Statistics sample for a container. */ -export class ContainerStatsResponse { +export interface ContainerStatsResponse { /** * Name of the container */ - 'Name'?: string | null; + Name?: string | null; + /** * ID of the container */ - 'Id'?: string | null; + Id?: string | null; + /** * Date and time at which this sample was collected. The value is formatted as [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) with nano-seconds. */ - 'Read'?: Date; + Read?: Date; + /** - * Date and time at which this first sample was collected. This field is not propagated if the \"one-shot\" option is set. If the \"one-shot\" option is set, this field may be omitted, empty, or set to a default date (`0001-01-01T00:00:00Z`). The value is formatted as [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) with nano-seconds. + * Date and time at which this first sample was collected. This field is not propagated if the \"one-shot\" option is set. If the \"one-shot\" option is set, this field may be omitted, empty, or set to a default date (`0001-01-01T00:00:00Z`). The value is formatted as [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) with nano-seconds. */ - 'Preread'?: Date; - 'PidsStats'?: ContainerPidsStats | null; - 'BlkioStats'?: ContainerBlkioStats | null; + Preread?: Date; + + PidsStats?: ContainerPidsStats | null; + + BlkioStats?: ContainerBlkioStats | null; + /** * The number of processors on the system. This field is Windows-specific and always zero for Linux containers. */ - 'NumProcs'?: number; - 'StorageStats'?: ContainerStorageStats | null; - 'CpuStats'?: ContainerCPUStats | null; - 'PrecpuStats'?: ContainerCPUStats | null; - 'MemoryStats'?: ContainerMemoryStats; + NumProcs?: number; + + StorageStats?: ContainerStorageStats | null; + + CpuStats?: ContainerCPUStats | null; + + PrecpuStats?: ContainerCPUStats | null; + + MemoryStats?: ContainerMemoryStats; + /** * Network statistics for the container per interface. This field is omitted if the container has no networking enabled. */ - 'Networks'?: any; + Networks?: any | null; } diff --git a/src/models/ContainerStatus.ts b/src/models/ContainerStatus.ts index aedeacd..b5d32c6 100644 --- a/src/models/ContainerStatus.ts +++ b/src/models/ContainerStatus.ts @@ -1,20 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * represents the status of a container. */ -export class ContainerStatus { - 'ContainerID'?: string; - 'PID'?: number; - 'ExitCode'?: number; +export interface ContainerStatus { + ContainerID?: string; + + PID?: number; + + ExitCode?: number; } diff --git a/src/models/ContainerStorageStats.ts b/src/models/ContainerStorageStats.ts index 4d68a04..c3acc8b 100644 --- a/src/models/ContainerStorageStats.ts +++ b/src/models/ContainerStorageStats.ts @@ -1,21 +1,32 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * StorageStats is the disk I/O stats for read/write on Windows. This type is Windows-specific and omitted for Linux containers. */ -export class ContainerStorageStats { - 'ReadCountNormalized'?: number | null; - 'ReadSizeBytes'?: number | null; - 'WriteCountNormalized'?: number | null; - 'WriteSizeBytes'?: number | null; +export interface ContainerStorageStats { + ReadCountNormalized?: number | null; + + ReadSizeBytes?: number | null; + + WriteCountNormalized?: number | null; + + WriteSizeBytes?: number | null; } diff --git a/src/models/ContainerSummary.ts b/src/models/ContainerSummary.ts index 5fd502f..7d9d0d4 100644 --- a/src/models/ContainerSummary.ts +++ b/src/models/ContainerSummary.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerSummaryHealth } from '../models/ContainerSummaryHealth.js'; @@ -17,71 +25,86 @@ import { MountPoint } from '../models/MountPoint.js'; import { OCIDescriptor } from '../models/OCIDescriptor.js'; import { PortSummary } from '../models/PortSummary.js'; -export class ContainerSummary { +export interface ContainerSummary { /** * The ID of this container as a 128-bit (64-character) hexadecimal string (32 bytes). */ - 'Id'?: string; + Id?: string; + /** - * The names associated with this container. Most containers have a single name, but when using legacy \"links\", the container can have multiple names. For historic reasons, names are prefixed with a forward-slash (`/`). + * The names associated with this container. Most containers have a single name, but when using legacy \"links\", the container can have multiple names. For historic reasons, names are prefixed with a forward-slash (`/`). */ - 'Names'?: Array; + Names?: Array; + /** - * The name or ID of the image used to create the container. This field shows the image reference as was specified when creating the container, which can be in its canonical form (e.g., `docker.io/library/ubuntu:latest` or `docker.io/library/ubuntu@sha256:72297848456d5d37d1262630108ab308d3e9ec7ed1c3286a32fe09856619a782`), short form (e.g., `ubuntu:latest`)), or the ID(-prefix) of the image (e.g., `72297848456d`). The content of this field can be updated at runtime if the image used to create the container is untagged, in which case the field is updated to contain the the image ID (digest) it was resolved to in its canonical, non-truncated form (e.g., `sha256:72297848456d5d37d1262630108ab308d3e9ec7ed1c3286a32fe09856619a782`). + * The name or ID of the image used to create the container. This field shows the image reference as was specified when creating the container, which can be in its canonical form (e.g., `docker.io/library/ubuntu:latest` or `docker.io/library/ubuntu@sha256:72297848456d5d37d1262630108ab308d3e9ec7ed1c3286a32fe09856619a782`), short form (e.g., `ubuntu:latest`)), or the ID(-prefix) of the image (e.g., `72297848456d`). The content of this field can be updated at runtime if the image used to create the container is untagged, in which case the field is updated to contain the the image ID (digest) it was resolved to in its canonical, non-truncated form (e.g., `sha256:72297848456d5d37d1262630108ab308d3e9ec7ed1c3286a32fe09856619a782`). */ - 'Image'?: string; + Image?: string; + /** * The ID (digest) of the image that this container was created from. */ - 'ImageID'?: string; - 'ImageManifestDescriptor'?: OCIDescriptor; + ImageID?: string; + + ImageManifestDescriptor?: OCIDescriptor; + /** * Command to run when starting the container */ - 'Command'?: string; + Command?: string; + /** * Date and time at which the container was created as a Unix timestamp (number of seconds since EPOCH). */ - 'Created'?: number; + Created?: number; + /** * Port-mappings for the container. */ - 'Ports'?: Array; + Ports?: Array; + /** * The size of files that have been created or changed by this container. This field is omitted by default, and only set when size is requested in the API request. */ - 'SizeRw'?: number | null; + SizeRw?: number | null; + /** * The total size of all files in the read-only layers from the image that the container uses. These layers can be shared between containers. This field is omitted by default, and only set when size is requested in the API request. */ - 'SizeRootFs'?: number | null; + SizeRootFs?: number | null; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * The state of this container. */ - 'State'?: ContainerSummaryStateEnum; + State?: ContainerSummaryStateEnum; + /** - * Additional human-readable status of this container (e.g. `Exit 0`) + * Additional human-readable status of this container (e.g. `Exit 0`) */ - 'Status'?: string; - 'HostConfig'?: ContainerSummaryHostConfig; - 'NetworkSettings'?: ContainerSummaryNetworkSettings; + Status?: string; + + HostConfig?: ContainerSummaryHostConfig; + + NetworkSettings?: ContainerSummaryNetworkSettings; + /** * List of mounts used by the container. */ - 'Mounts'?: Array; - 'Health'?: ContainerSummaryHealth; -} + Mounts?: Array; -export enum ContainerSummaryStateEnum { - Created = 'created', - Running = 'running', - Paused = 'paused', - Restarting = 'restarting', - Exited = 'exited', - Removing = 'removing', - Dead = 'dead', + Health?: ContainerSummaryHealth; } + +export type ContainerSummaryStateEnum = + | 'created' + | 'running' + | 'paused' + | 'restarting' + | 'exited' + | 'removing' + | 'dead'; diff --git a/src/models/ContainerSummaryHealth.ts b/src/models/ContainerSummaryHealth.ts index e96f64c..34d7645 100644 --- a/src/models/ContainerSummaryHealth.ts +++ b/src/models/ContainerSummaryHealth.ts @@ -1,32 +1,40 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Summary of health status Added in v1.52, before that version all container summary not include Health. After this attribute introduced, it includes containers with no health checks configured, or containers that are not running with none */ -export class ContainerSummaryHealth { +export interface ContainerSummaryHealth { /** * the health status of the container */ - 'Status'?: ContainerSummaryHealthStatusEnum; + Status?: ContainerSummaryHealthStatusEnum; + /** * FailingStreak is the number of consecutive failures */ - 'FailingStreak'?: number; + FailingStreak?: number; } -export enum ContainerSummaryHealthStatusEnum { - None = 'none', - Starting = 'starting', - Healthy = 'healthy', - Unhealthy = 'unhealthy', -} +export type ContainerSummaryHealthStatusEnum = + | 'none' + | 'starting' + | 'healthy' + | 'unhealthy'; diff --git a/src/models/ContainerSummaryHostConfig.ts b/src/models/ContainerSummaryHostConfig.ts index 0705688..3053257 100644 --- a/src/models/ContainerSummaryHostConfig.ts +++ b/src/models/ContainerSummaryHostConfig.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Summary of host-specific runtime information of the container. This is a reduced set of information in the container\'s \"HostConfig\" as available in the container \"inspect\" response. */ -export class ContainerSummaryHostConfig { +export interface ContainerSummaryHostConfig { /** - * Networking mode (`host`, `none`, `container:`) or name of the primary network the container is using. This field is primarily for backward compatibility. The container can be connected to multiple networks for which information can be found in the `NetworkSettings.Networks` field, which enumerates settings per network. + * Networking mode (`host`, `none`, `container:<id>`) or name of the primary network the container is using. This field is primarily for backward compatibility. The container can be connected to multiple networks for which information can be found in the `NetworkSettings.Networks` field, which enumerates settings per network. */ - 'NetworkMode'?: string; + NetworkMode?: string; + /** * Arbitrary key-value metadata attached to the container. */ - 'Annotations'?: { [key: string]: string } | null; + Annotations?: { [key: string]: string } | null; } diff --git a/src/models/ContainerSummaryNetworkSettings.ts b/src/models/ContainerSummaryNetworkSettings.ts index 390d35b..e5c795f 100644 --- a/src/models/ContainerSummaryNetworkSettings.ts +++ b/src/models/ContainerSummaryNetworkSettings.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointSettings } from '../models/EndpointSettings.js'; @@ -15,9 +23,9 @@ import { EndpointSettings } from '../models/EndpointSettings.js'; /** * Summary of the container\'s network settings */ -export class ContainerSummaryNetworkSettings { +export interface ContainerSummaryNetworkSettings { /** * Summary of network-settings for each network the container is attached to. */ - 'Networks'?: { [key: string]: EndpointSettings }; + Networks?: { [key: string]: EndpointSettings }; } diff --git a/src/models/ContainerThrottlingData.ts b/src/models/ContainerThrottlingData.ts index 720c716..afd2e82 100644 --- a/src/models/ContainerThrottlingData.ts +++ b/src/models/ContainerThrottlingData.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * CPU throttling stats of the container. This type is Linux-specific and omitted for Windows containers. */ -export class ContainerThrottlingData { +export interface ContainerThrottlingData { /** * Number of periods with throttling active. */ - 'Periods'?: number; + Periods?: number; + /** * Number of periods when the container hit its throttling limit. */ - 'ThrottledPeriods'?: number; + ThrottledPeriods?: number; + /** * Aggregated time (in nanoseconds) the container was throttled for. */ - 'ThrottledTime'?: number; + ThrottledTime?: number; } diff --git a/src/models/ContainerTopResponse.ts b/src/models/ContainerTopResponse.ts index 4d758d8..747aedc 100644 --- a/src/models/ContainerTopResponse.ts +++ b/src/models/ContainerTopResponse.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Container \"top\" response. */ -export class ContainerTopResponse { +export interface ContainerTopResponse { /** * The ps column titles */ - 'Titles'?: Array; + Titles?: Array; + /** * Each process running in the container, where each process is an array of values corresponding to the titles. */ - 'Processes'?: Array>; + Processes?: Array>; } diff --git a/src/models/ContainerUpdateRequest.ts b/src/models/ContainerUpdateRequest.ts index 3df8855..5425ee8 100644 --- a/src/models/ContainerUpdateRequest.ts +++ b/src/models/ContainerUpdateRequest.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { DeviceMapping } from '../models/DeviceMapping.js'; @@ -17,130 +25,161 @@ import { ResourcesUlimitsInner } from '../models/ResourcesUlimitsInner.js'; import { RestartPolicy } from '../models/RestartPolicy.js'; import { ThrottleDevice } from '../models/ThrottleDevice.js'; -export class ContainerUpdateRequest { +export interface ContainerUpdateRequest { /** - * An integer value representing this container\'s relative CPU weight versus other containers. + * An integer value representing this container\'s relative CPU weight versus other containers. */ - 'CpuShares'?: number; + CpuShares?: number; + /** * Memory limit in bytes. */ - 'Memory'?: number; + Memory?: number; + /** - * Path to `cgroups` under which the container\'s `cgroup` is created. If the path is not absolute, the path is considered to be relative to the `cgroups` path of the init process. Cgroups are created if they do not already exist. + * Path to `cgroups` under which the container\'s `cgroup` is created. If the path is not absolute, the path is considered to be relative to the `cgroups` path of the init process. Cgroups are created if they do not already exist. */ - 'CgroupParent'?: string; + CgroupParent?: string; + /** * Block IO weight (relative weight). */ - 'BlkioWeight'?: number; + BlkioWeight?: number; + /** - * Block IO weight (relative device weight) in the form: ``` [{\"Path\": \"device_path\", \"Weight\": weight}] ``` + * Block IO weight (relative device weight) in the form: ``` [{\"Path\": \"device_path\", \"Weight\": weight}] ``` */ - 'BlkioWeightDevice'?: Array; + BlkioWeightDevice?: Array; + /** - * Limit read rate (bytes per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit read rate (bytes per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceReadBps'?: Array; + BlkioDeviceReadBps?: Array; + /** - * Limit write rate (bytes per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit write rate (bytes per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceWriteBps'?: Array; + BlkioDeviceWriteBps?: Array; + /** - * Limit read rate (IO per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit read rate (IO per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceReadIOps'?: Array; + BlkioDeviceReadIOps?: Array; + /** - * Limit write rate (IO per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit write rate (IO per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceWriteIOps'?: Array; + BlkioDeviceWriteIOps?: Array; + /** * The length of a CPU period in microseconds. */ - 'CpuPeriod'?: number; + CpuPeriod?: number; + /** * Microseconds of CPU time that the container can get in a CPU period. */ - 'CpuQuota'?: number; + CpuQuota?: number; + /** * The length of a CPU real-time period in microseconds. Set to 0 to allocate no time allocated to real-time tasks. */ - 'CpuRealtimePeriod'?: number; + CpuRealtimePeriod?: number; + /** * The length of a CPU real-time runtime in microseconds. Set to 0 to allocate no time allocated to real-time tasks. */ - 'CpuRealtimeRuntime'?: number; + CpuRealtimeRuntime?: number; + /** - * CPUs in which to allow execution (e.g., `0-3`, `0,1`). + * CPUs in which to allow execution (e.g., `0-3`, `0,1`). */ - 'CpusetCpus'?: string; + CpusetCpus?: string; + /** * Memory nodes (MEMs) in which to allow execution (0-3, 0,1). Only effective on NUMA systems. */ - 'CpusetMems'?: string; + CpusetMems?: string; + /** * A list of devices to add to the container. */ - 'Devices'?: Array; + Devices?: Array; + /** * a list of cgroup rules to apply to the container */ - 'DeviceCgroupRules'?: Array; + DeviceCgroupRules?: Array; + /** * A list of requests for devices to be sent to device drivers. */ - 'DeviceRequests'?: Array; + DeviceRequests?: Array; + /** * Hard limit for kernel TCP buffer memory (in bytes). Depending on the OCI runtime in use, this option may be ignored. It is no longer supported by the default (runc) runtime. This field is omitted when empty. */ - 'KernelMemoryTCP'?: number; + KernelMemoryTCP?: number; + /** * Memory soft limit in bytes. */ - 'MemoryReservation'?: number; + MemoryReservation?: number; + /** - * Total memory limit (memory + swap). Set as `-1` to enable unlimited swap. + * Total memory limit (memory + swap). Set as `-1` to enable unlimited swap. */ - 'MemorySwap'?: number; + MemorySwap?: number; + /** - * Tune a container\'s memory swappiness behavior. Accepts an integer between 0 and 100. + * Tune a container\'s memory swappiness behavior. Accepts an integer between 0 and 100. */ - 'MemorySwappiness'?: number; + MemorySwappiness?: number; + /** - * CPU quota in units of 10-9 CPUs. + * CPU quota in units of 10<sup>-9</sup> CPUs. */ - 'NanoCpus'?: number; + NanoCpus?: number; + /** * Disable OOM Killer for the container. */ - 'OomKillDisable'?: boolean; + OomKillDisable?: boolean; + /** * Run an init inside the container that forwards signals and reaps processes. This field is omitted if empty, and the default (as configured on the daemon) is used. */ - 'Init'?: boolean | null; + Init?: boolean | null; + /** - * Tune a container\'s PIDs limit. Set `0` or `-1` for unlimited, or `null` to not change. + * Tune a container\'s PIDs limit. Set `0` or `-1` for unlimited, or `null` to not change. */ - 'PidsLimit'?: number | null; + PidsLimit?: number | null; + /** - * A list of resource limits to set in the container. For example: ``` {\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048} ``` + * A list of resource limits to set in the container. For example: ``` {\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048} ``` */ - 'Ulimits'?: Array; + Ulimits?: Array; + /** - * The number of usable CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. + * The number of usable CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. */ - 'CpuCount'?: number; + CpuCount?: number; + /** - * The usable percentage of the available CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. + * The usable percentage of the available CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. */ - 'CpuPercent'?: number; + CpuPercent?: number; + /** * Maximum IOps for the container system drive (Windows only) */ - 'IOMaximumIOps'?: number; + IOMaximumIOps?: number; + /** * Maximum IO in bytes per second for the container system drive (Windows only). */ - 'IOMaximumBandwidth'?: number; - 'RestartPolicy'?: RestartPolicy; + IOMaximumBandwidth?: number; + + RestartPolicy?: RestartPolicy; } diff --git a/src/models/ContainerUpdateResponse.ts b/src/models/ContainerUpdateResponse.ts index 92ad353..f3f6115 100644 --- a/src/models/ContainerUpdateResponse.ts +++ b/src/models/ContainerUpdateResponse.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Response for a successful container-update. */ -export class ContainerUpdateResponse { +export interface ContainerUpdateResponse { /** * Warnings encountered when updating the container. */ - 'Warnings'?: Array; + Warnings?: Array; } diff --git a/src/models/ContainerWaitExitError.ts b/src/models/ContainerWaitExitError.ts index b75f987..3c2d2cf 100644 --- a/src/models/ContainerWaitExitError.ts +++ b/src/models/ContainerWaitExitError.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * container waiting error, if any */ -export class ContainerWaitExitError { +export interface ContainerWaitExitError { /** * Details of an error */ - 'Message'?: string; + Message?: string; } diff --git a/src/models/ContainerWaitResponse.ts b/src/models/ContainerWaitResponse.ts index b9dea3d..89469ca 100644 --- a/src/models/ContainerWaitResponse.ts +++ b/src/models/ContainerWaitResponse.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerWaitExitError } from '../models/ContainerWaitExitError.js'; @@ -15,10 +23,11 @@ import { ContainerWaitExitError } from '../models/ContainerWaitExitError.js'; /** * OK response to ContainerWait operation */ -export class ContainerWaitResponse { +export interface ContainerWaitResponse { /** * Exit code of the container */ - 'StatusCode': number; - 'Error'?: ContainerWaitExitError; + StatusCode: number; + + Error?: ContainerWaitExitError; } diff --git a/src/models/ContainerdInfo.ts b/src/models/ContainerdInfo.ts index 963c9a2..f3e4318 100644 --- a/src/models/ContainerdInfo.ts +++ b/src/models/ContainerdInfo.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerdInfoNamespaces } from '../models/ContainerdInfoNamespaces.js'; @@ -15,10 +23,11 @@ import { ContainerdInfoNamespaces } from '../models/ContainerdInfoNamespaces.js' /** * Information for connecting to the containerd instance that is used by the daemon. This is included for debugging purposes only. */ -export class ContainerdInfo { +export interface ContainerdInfo { /** * The address of the containerd socket. */ - 'Address'?: string; - 'Namespaces'?: ContainerdInfoNamespaces; + Address?: string; + + Namespaces?: ContainerdInfoNamespaces; } diff --git a/src/models/ContainerdInfoNamespaces.ts b/src/models/ContainerdInfoNamespaces.ts index 8587acc..7ded4e7 100644 --- a/src/models/ContainerdInfoNamespaces.ts +++ b/src/models/ContainerdInfoNamespaces.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The namespaces that the daemon uses for running containers and plugins in containerd. These namespaces can be configured in the daemon configuration, and are considered to be used exclusively by the daemon, Tampering with the containerd instance may cause unexpected behavior. As these namespaces are considered to be exclusively accessed by the daemon, it is not recommended to change these values, or to change them to a value that is used by other systems, such as cri-containerd. */ -export class ContainerdInfoNamespaces { +export interface ContainerdInfoNamespaces { /** - * The default containerd namespace used for containers managed by the daemon. The default namespace for containers is \"moby\", but will be suffixed with the `.` of the remapped `root` if user-namespaces are enabled and the containerd image-store is used. + * The default containerd namespace used for containers managed by the daemon. The default namespace for containers is \"moby\", but will be suffixed with the `<uid>.<gid>` of the remapped `root` if user-namespaces are enabled and the containerd image-store is used. */ - 'Containers'?: string; + Containers?: string; + /** - * The default containerd namespace used for plugins managed by the daemon. The default namespace for plugins is \"plugins.moby\", but will be suffixed with the `.` of the remapped `root` if user-namespaces are enabled and the containerd image-store is used. + * The default containerd namespace used for plugins managed by the daemon. The default namespace for plugins is \"plugins.moby\", but will be suffixed with the `<uid>.<gid>` of the remapped `root` if user-namespaces are enabled and the containerd image-store is used. */ - 'Plugins'?: string; + Plugins?: string; } diff --git a/src/models/CreateImageInfo.ts b/src/models/CreateImageInfo.ts index f7fe8ef..9e16fe7 100644 --- a/src/models/CreateImageInfo.ts +++ b/src/models/CreateImageInfo.ts @@ -1,21 +1,32 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ErrorDetail } from '../models/ErrorDetail.js'; import { ProgressDetail } from '../models/ProgressDetail.js'; -export class CreateImageInfo { - 'Id'?: string; - 'ErrorDetail'?: ErrorDetail; - 'Status'?: string; - 'ProgressDetail'?: ProgressDetail; +export interface CreateImageInfo { + Id?: string; + + ErrorDetail?: ErrorDetail; + + Status?: string; + + ProgressDetail?: ProgressDetail; } diff --git a/src/models/DeviceInfo.ts b/src/models/DeviceInfo.ts index 2064cb9..5308856 100644 --- a/src/models/DeviceInfo.ts +++ b/src/models/DeviceInfo.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * DeviceInfo represents a device that can be used by a container. */ -export class DeviceInfo { +export interface DeviceInfo { /** * The origin device driver. */ - 'Source'?: string; + Source?: string; + /** - * The unique identifier for the device within its source driver. For CDI devices, this would be an FQDN like \"vendor.com/gpu=0\". + * The unique identifier for the device within its source driver. For CDI devices, this would be an FQDN like \"vendor.com/gpu=0\". */ - 'ID'?: string; + ID?: string; } diff --git a/src/models/DeviceMapping.ts b/src/models/DeviceMapping.ts index 6411082..6ff82ae 100644 --- a/src/models/DeviceMapping.ts +++ b/src/models/DeviceMapping.ts @@ -1,20 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * A device mapping between the host and container */ -export class DeviceMapping { - 'PathOnHost'?: string; - 'PathInContainer'?: string; - 'CgroupPermissions'?: string; +export interface DeviceMapping { + PathOnHost?: string; + + PathInContainer?: string; + + CgroupPermissions?: string; } diff --git a/src/models/DeviceRequest.ts b/src/models/DeviceRequest.ts index 78dcaf4..c644265 100644 --- a/src/models/DeviceRequest.ts +++ b/src/models/DeviceRequest.ts @@ -1,31 +1,43 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * A request for devices to be sent to device drivers */ -export class DeviceRequest { +export interface DeviceRequest { /** * The name of the device driver to use for this request. Note that if this is specified the capabilities are ignored when selecting a device driver. */ - 'Driver'?: string; - 'Count'?: number; - 'DeviceIDs'?: Array; + Driver?: string; + + Count?: number; + + DeviceIDs?: Array; + /** * A list of capabilities; an OR list of AND lists of capabilities. Note that if a driver is specified the capabilities have no effect on selecting a driver as the driver name is used directly. Note that if no driver is specified the capabilities are used to select a driver with the required capabilities. */ - 'Capabilities'?: Array>; + Capabilities?: Array>; + /** * Driver-specific options, specified as a key/value pairs. These options are passed directly to the driver. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; } diff --git a/src/models/DistributionInspect.ts b/src/models/DistributionInspect.ts index e44bc99..d505f75 100644 --- a/src/models/DistributionInspect.ts +++ b/src/models/DistributionInspect.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { OCIDescriptor } from '../models/OCIDescriptor.js'; @@ -16,10 +24,11 @@ import { OCIPlatform } from '../models/OCIPlatform.js'; /** * Describes the result obtained from contacting the registry to retrieve image metadata. */ -export class DistributionInspect { - 'Descriptor': OCIDescriptor; +export interface DistributionInspect { + Descriptor: OCIDescriptor; + /** * An array containing all platforms supported by the image. */ - 'Platforms': Array; + Platforms: Array; } diff --git a/src/models/Driver.ts b/src/models/Driver.ts index 5159777..8f794f4 100644 --- a/src/models/Driver.ts +++ b/src/models/Driver.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Driver represents a driver (network, logging, secrets). */ -export class Driver { +export interface Driver { /** * Name of the driver. */ - 'Name': string; + Name: string; + /** * Key/value map of driver-specific options. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; } diff --git a/src/models/DriverData.ts b/src/models/DriverData.ts index ca69382..e43e3a0 100644 --- a/src/models/DriverData.ts +++ b/src/models/DriverData.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Information about the storage driver used to store the container\'s and image\'s filesystem. */ -export class DriverData { +export interface DriverData { /** * Name of the storage driver. */ - 'Name': string; + Name: string; + /** * Low-level storage metadata, provided as key/value pairs. This information is driver-specific, and depends on the storage-driver in use, and should be used for informational purposes only. */ - 'Data': { [key: string]: string }; + Data: { [key: string]: string }; } diff --git a/src/models/EndpointIPAMConfig.ts b/src/models/EndpointIPAMConfig.ts index 651af8f..bed10a2 100644 --- a/src/models/EndpointIPAMConfig.ts +++ b/src/models/EndpointIPAMConfig.ts @@ -1,20 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * EndpointIPAMConfig represents an endpoint\'s IPAM configuration. */ -export class EndpointIPAMConfig { - 'IPv4Address'?: string; - 'IPv6Address'?: string; - 'LinkLocalIPs'?: Array; +export interface EndpointIPAMConfig { + IPv4Address?: string; + + IPv6Address?: string; + + LinkLocalIPs?: Array; } diff --git a/src/models/EndpointPortConfig.ts b/src/models/EndpointPortConfig.ts index f7a058d..1bfcbf6 100644 --- a/src/models/EndpointPortConfig.ts +++ b/src/models/EndpointPortConfig.ts @@ -1,38 +1,43 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class EndpointPortConfig { - 'Name'?: string; - 'Protocol'?: EndpointPortConfigProtocolEnum; +export interface EndpointPortConfig { + Name?: string; + + Protocol?: EndpointPortConfigProtocolEnum; + /** * The port inside the container. */ - 'TargetPort'?: number; + TargetPort?: number; + /** * The port on the swarm hosts. */ - 'PublishedPort'?: number; + PublishedPort?: number; + /** - * The mode in which port is published.


- \"ingress\" makes the target port accessible on every node, regardless of whether there is a task for the service running on that node or not. - \"host\" bypasses the routing mesh and publish the port directly on the swarm node where that service is running. + * The mode in which port is published. <p><br /></p> - \"ingress\" makes the target port accessible on every node, regardless of whether there is a task for the service running on that node or not. - \"host\" bypasses the routing mesh and publish the port directly on the swarm node where that service is running. */ - 'PublishMode'?: EndpointPortConfigPublishModeEnum; + PublishMode?: EndpointPortConfigPublishModeEnum; } -export enum EndpointPortConfigProtocolEnum { - Tcp = 'tcp', - Udp = 'udp', - Sctp = 'sctp', -} -export enum EndpointPortConfigPublishModeEnum { - Ingress = 'ingress', - Host = 'host', -} +export type EndpointPortConfigProtocolEnum = 'tcp' | 'udp' | 'sctp'; +export type EndpointPortConfigPublishModeEnum = 'ingress' | 'host'; diff --git a/src/models/EndpointResource.ts b/src/models/EndpointResource.ts index 668268d..edcd5db 100644 --- a/src/models/EndpointResource.ts +++ b/src/models/EndpointResource.ts @@ -1,22 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * contains network resources allocated and used for a container in a network. */ -export class EndpointResource { - 'Name'?: string; - 'EndpointID'?: string; - 'MacAddress'?: string; - 'IPv4Address'?: string; - 'IPv6Address'?: string; +export interface EndpointResource { + Name?: string; + + EndpointID?: string; + + MacAddress?: string; + + IPv4Address?: string; + + IPv6Address?: string; } diff --git a/src/models/EndpointSettings.ts b/src/models/EndpointSettings.ts index 9bca776..7c36974 100644 --- a/src/models/EndpointSettings.ts +++ b/src/models/EndpointSettings.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointIPAMConfig } from '../models/EndpointIPAMConfig.js'; @@ -15,56 +23,70 @@ import { EndpointIPAMConfig } from '../models/EndpointIPAMConfig.js'; /** * Configuration for a network endpoint. */ -export class EndpointSettings { - 'IPAMConfig'?: EndpointIPAMConfig | null; - 'Links'?: Array; +export interface EndpointSettings { + IPAMConfig?: EndpointIPAMConfig | null; + + Links?: Array; + /** * MAC address for the endpoint on this network. The network driver might ignore this parameter. */ - 'MacAddress'?: string; - 'Aliases'?: Array; + MacAddress?: string; + + Aliases?: Array; + /** * DriverOpts is a mapping of driver options and values. These options are passed directly to the driver and are driver specific. */ - 'DriverOpts'?: { [key: string]: string } | null; + DriverOpts?: { [key: string]: string } | null; + /** * This property determines which endpoint will provide the default gateway for a container. The endpoint with the highest priority will be used. If multiple endpoints have the same priority, endpoints are lexicographically sorted based on their network name, and the one that sorts first is picked. */ - 'GwPriority'?: number; + GwPriority?: number; + /** * Unique ID of the network. */ - 'NetworkID'?: string; + NetworkID?: string; + /** * Unique ID for the service endpoint in a Sandbox. */ - 'EndpointID'?: string; + EndpointID?: string; + /** * Gateway address for this network. */ - 'Gateway'?: string; + Gateway?: string; + /** * IPv4 address. */ - 'IPAddress'?: string; + IPAddress?: string; + /** * Mask length of the IPv4 address. */ - 'IPPrefixLen'?: number; + IPPrefixLen?: number; + /** * IPv6 gateway address. */ - 'IPv6Gateway'?: string; + IPv6Gateway?: string; + /** * Global IPv6 address. */ - 'GlobalIPv6Address'?: string; + GlobalIPv6Address?: string; + /** * Mask length of the global IPv6 address. */ - 'GlobalIPv6PrefixLen'?: number; + GlobalIPv6PrefixLen?: number; + /** - * List of all DNS names an endpoint has on a specific network. This list is based on the container name, network aliases, container short ID, and hostname. These DNS names are non-fully qualified but can contain several dots. You can get fully qualified DNS names by appending `.`. For instance, if container name is `my.ctr` and the network is named `testnet`, `DNSNames` will contain `my.ctr` and the FQDN will be `my.ctr.testnet`. + * List of all DNS names an endpoint has on a specific network. This list is based on the container name, network aliases, container short ID, and hostname. These DNS names are non-fully qualified but can contain several dots. You can get fully qualified DNS names by appending `.<network-name>`. For instance, if container name is `my.ctr` and the network is named `testnet`, `DNSNames` will contain `my.ctr` and the FQDN will be `my.ctr.testnet`. */ - 'DNSNames'?: Array; + DNSNames?: Array; } diff --git a/src/models/EndpointSpec.ts b/src/models/EndpointSpec.ts index 5e51b3d..383a409 100644 --- a/src/models/EndpointSpec.ts +++ b/src/models/EndpointSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointPortConfig } from '../models/EndpointPortConfig.js'; @@ -15,18 +23,16 @@ import { EndpointPortConfig } from '../models/EndpointPortConfig.js'; /** * Properties that can be configured to access and load balance a service. */ -export class EndpointSpec { +export interface EndpointSpec { /** * The mode of resolution to use for internal load balancing between tasks. */ - 'Mode'?: EndpointSpecModeEnum; + Mode?: EndpointSpecModeEnum; + /** - * List of exposed ports that this service is accessible on from the outside. Ports can only be provided if `vip` resolution mode is used. + * List of exposed ports that this service is accessible on from the outside. Ports can only be provided if `vip` resolution mode is used. */ - 'Ports'?: Array; + Ports?: Array; } -export enum EndpointSpecModeEnum { - Vip = 'vip', - Dnsrr = 'dnsrr', -} +export type EndpointSpecModeEnum = 'vip' | 'dnsrr'; diff --git a/src/models/EngineDescription.ts b/src/models/EngineDescription.ts index 83e9c2a..cf57b81 100644 --- a/src/models/EngineDescription.ts +++ b/src/models/EngineDescription.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EngineDescriptionPluginsInner } from '../models/EngineDescriptionPluginsInner.js'; @@ -15,8 +23,10 @@ import { EngineDescriptionPluginsInner } from '../models/EngineDescriptionPlugin /** * EngineDescription provides information about an engine. */ -export class EngineDescription { - 'EngineVersion'?: string; - 'Labels'?: { [key: string]: string }; - 'Plugins'?: Array; +export interface EngineDescription { + EngineVersion?: string; + + Labels?: { [key: string]: string }; + + Plugins?: Array; } diff --git a/src/models/EngineDescriptionPluginsInner.ts b/src/models/EngineDescriptionPluginsInner.ts index a25bd81..9707a3b 100644 --- a/src/models/EngineDescriptionPluginsInner.ts +++ b/src/models/EngineDescriptionPluginsInner.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class EngineDescriptionPluginsInner { - 'Type'?: string; - 'Name'?: string; +export interface EngineDescriptionPluginsInner { + Type?: string; + + Name?: string; } diff --git a/src/models/ErrorDetail.ts b/src/models/ErrorDetail.ts index 1805509..db1a1e8 100644 --- a/src/models/ErrorDetail.ts +++ b/src/models/ErrorDetail.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ErrorDetail { - 'Code'?: number; - 'Message'?: string; +export interface ErrorDetail { + Code?: number; + + Message?: string; } diff --git a/src/models/ErrorResponse.ts b/src/models/ErrorResponse.ts index 8585ce0..68c99a7 100644 --- a/src/models/ErrorResponse.ts +++ b/src/models/ErrorResponse.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Represents an error. */ -export class ErrorResponse { +export interface ErrorResponse { /** * The error message. */ - 'Message': string; + Message: string; } diff --git a/src/models/EventActor.ts b/src/models/EventActor.ts index ccc49fc..44d22d7 100644 --- a/src/models/EventActor.ts +++ b/src/models/EventActor.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Actor describes something that generates events, like a container, network, or a volume. */ -export class EventActor { +export interface EventActor { /** * The ID of the object emitting the event */ - 'ID'?: string; + ID?: string; + /** * Various key/value attributes of the object, depending on its type. */ - 'Attributes'?: { [key: string]: string }; + Attributes?: { [key: string]: string }; } diff --git a/src/models/EventMessage.ts b/src/models/EventMessage.ts index 3ed2777..96bd0fe 100644 --- a/src/models/EventMessage.ts +++ b/src/models/EventMessage.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EventActor } from '../models/EventActor.js'; @@ -15,44 +23,45 @@ import { EventActor } from '../models/EventActor.js'; /** * EventMessage represents the information an event contains. */ -export class EventMessage { +export interface EventMessage { /** * The type of object emitting the event */ - 'Type'?: EventMessageTypeEnum; + Type?: EventMessageTypeEnum; + /** * The type of event */ - 'Action'?: string; - 'Actor'?: EventActor; + Action?: string; + + Actor?: EventActor; + /** - * Scope of the event. Engine events are `local` scope. Cluster (Swarm) events are `swarm` scope. + * Scope of the event. Engine events are `local` scope. Cluster (Swarm) events are `swarm` scope. */ - 'Scope'?: EventMessageScopeEnum; + Scope?: EventMessageScopeEnum; + /** * Timestamp of event */ - 'Time'?: number; + Time?: number; + /** * Timestamp of event, with nanosecond accuracy */ - 'TimeNano'?: number; + TimeNano?: number; } -export enum EventMessageTypeEnum { - Builder = 'builder', - Config = 'config', - Container = 'container', - Daemon = 'daemon', - Image = 'image', - Network = 'network', - Node = 'node', - Plugin = 'plugin', - Secret = 'secret', - Service = 'service', - Volume = 'volume', -} -export enum EventMessageScopeEnum { - Local = 'local', - Swarm = 'swarm', -} +export type EventMessageTypeEnum = + | 'builder' + | 'config' + | 'container' + | 'daemon' + | 'image' + | 'network' + | 'node' + | 'plugin' + | 'secret' + | 'service' + | 'volume'; +export type EventMessageScopeEnum = 'local' | 'swarm'; diff --git a/src/models/ExecConfig.ts b/src/models/ExecConfig.ts index fb6811e..af3e08a 100644 --- a/src/models/ExecConfig.ts +++ b/src/models/ExecConfig.ts @@ -1,58 +1,76 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ExecConfig { +export interface ExecConfig { /** - * Attach to `stdin` of the exec command. + * Attach to `stdin` of the exec command. */ - 'AttachStdin'?: boolean; + AttachStdin?: boolean; + /** - * Attach to `stdout` of the exec command. + * Attach to `stdout` of the exec command. */ - 'AttachStdout'?: boolean; + AttachStdout?: boolean; + /** - * Attach to `stderr` of the exec command. + * Attach to `stderr` of the exec command. */ - 'AttachStderr'?: boolean; + AttachStderr?: boolean; + /** - * Initial console size, as an `[height, width]` array. + * Initial console size, as an `[height, width]` array. */ - 'ConsoleSize'?: Array | null; + ConsoleSize?: Array | null; + /** - * Override the key sequence for detaching a container. Format is a single character `[a-Z]` or `ctrl-` where `` is one of: `a-z`, `@`, `^`, `[`, `,` or `_`. + * Override the key sequence for detaching a container. Format is a single character `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`, `[`, `,` or `_`. */ - 'DetachKeys'?: string; + DetachKeys?: string; + /** * Allocate a pseudo-TTY. */ - 'Tty'?: boolean; + Tty?: boolean; + /** - * A list of environment variables in the form `[\"VAR=value\", ...]`. + * A list of environment variables in the form `[\"VAR=value\", ...]`. */ - 'Env'?: Array; + Env?: Array; + /** * Command to run, as a string or array of strings. */ - 'Cmd'?: Array; + Cmd?: Array; + /** * Runs the exec process with extended privileges. */ - 'Privileged'?: boolean; + Privileged?: boolean; + /** - * The user, and optionally, group to run the exec process inside the container. Format is one of: `user`, `user:group`, `uid`, or `uid:gid`. + * The user, and optionally, group to run the exec process inside the container. Format is one of: `user`, `user:group`, `uid`, or `uid:gid`. */ - 'User'?: string; + User?: string; + /** * The working directory for the exec process inside the container. */ - 'WorkingDir'?: string; + WorkingDir?: string; } diff --git a/src/models/ExecInspectResponse.ts b/src/models/ExecInspectResponse.ts index 27a5e0c..b32274c 100644 --- a/src/models/ExecInspectResponse.ts +++ b/src/models/ExecInspectResponse.ts @@ -1,30 +1,48 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ProcessConfig } from '../models/ProcessConfig.js'; -export class ExecInspectResponse { - 'CanRemove'?: boolean; - 'DetachKeys'?: string; - 'ID'?: string; - 'Running'?: boolean; - 'ExitCode'?: number; - 'ProcessConfig'?: ProcessConfig; - 'OpenStdin'?: boolean; - 'OpenStderr'?: boolean; - 'OpenStdout'?: boolean; - 'ContainerID'?: string; +export interface ExecInspectResponse { + CanRemove?: boolean; + + DetachKeys?: string; + + ID?: string; + + Running?: boolean; + + ExitCode?: number; + + ProcessConfig?: ProcessConfig; + + OpenStdin?: boolean; + + OpenStderr?: boolean; + + OpenStdout?: boolean; + + ContainerID?: string; + /** * The system process ID for the exec process. */ - 'Pid'?: number; + Pid?: number; } diff --git a/src/models/ExecStartConfig.ts b/src/models/ExecStartConfig.ts index be416c4..ccace0f 100644 --- a/src/models/ExecStartConfig.ts +++ b/src/models/ExecStartConfig.ts @@ -1,26 +1,36 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ExecStartConfig { +export interface ExecStartConfig { /** * Detach from the command. */ - 'Detach'?: boolean; + Detach?: boolean; + /** * Allocate a pseudo-TTY. */ - 'Tty'?: boolean; + Tty?: boolean; + /** - * Initial console size, as an `[height, width]` array. + * Initial console size, as an `[height, width]` array. */ - 'ConsoleSize'?: Array | null; + ConsoleSize?: Array | null; } diff --git a/src/models/FilesystemChange.ts b/src/models/FilesystemChange.ts index 04f060f..4cb9752 100644 --- a/src/models/FilesystemChange.ts +++ b/src/models/FilesystemChange.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ChangeType } from '../models/ChangeType.js'; @@ -15,10 +23,11 @@ import { ChangeType } from '../models/ChangeType.js'; /** * Change in the container\'s filesystem. */ -export class FilesystemChange { +export interface FilesystemChange { /** * Path to file or directory that has changed. */ - 'Path': string; - 'Kind': ChangeType; + Path: string; + + Kind: ChangeType; } diff --git a/src/models/FirewallInfo.ts b/src/models/FirewallInfo.ts index dd1dbe3..a833281 100644 --- a/src/models/FirewallInfo.ts +++ b/src/models/FirewallInfo.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Information about the daemon\'s firewalling configuration. This field is currently only used on Linux, and omitted on other platforms. */ -export class FirewallInfo { +export interface FirewallInfo { /** * The name of the firewall backend driver. */ - 'Driver'?: string; + Driver?: string; + /** - * Information about the firewall backend, provided as \"label\" / \"value\" pairs.


> **Note**: The information returned in this field, including the > formatting of values and labels, should not be considered stable, > and may change without notice. + * Information about the firewall backend, provided as \"label\" / \"value\" pairs. <p><br /></p> > **Note**: The information returned in this field, including the > formatting of values and labels, should not be considered stable, > and may change without notice. */ - 'Info'?: Array>; + Info?: Array>; } diff --git a/src/models/GenericResourcesInner.ts b/src/models/GenericResourcesInner.ts index 114a396..f095d0f 100644 --- a/src/models/GenericResourcesInner.ts +++ b/src/models/GenericResourcesInner.ts @@ -1,19 +1,28 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { GenericResourcesInnerDiscreteResourceSpec } from '../models/GenericResourcesInnerDiscreteResourceSpec.js'; import { GenericResourcesInnerNamedResourceSpec } from '../models/GenericResourcesInnerNamedResourceSpec.js'; -export class GenericResourcesInner { - 'NamedResourceSpec'?: GenericResourcesInnerNamedResourceSpec; - 'DiscreteResourceSpec'?: GenericResourcesInnerDiscreteResourceSpec; +export interface GenericResourcesInner { + NamedResourceSpec?: GenericResourcesInnerNamedResourceSpec; + + DiscreteResourceSpec?: GenericResourcesInnerDiscreteResourceSpec; } diff --git a/src/models/GenericResourcesInnerDiscreteResourceSpec.ts b/src/models/GenericResourcesInnerDiscreteResourceSpec.ts index 2cc8dfe..8d6a744 100644 --- a/src/models/GenericResourcesInnerDiscreteResourceSpec.ts +++ b/src/models/GenericResourcesInnerDiscreteResourceSpec.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class GenericResourcesInnerDiscreteResourceSpec { - 'Kind'?: string; - 'Value'?: number; +export interface GenericResourcesInnerDiscreteResourceSpec { + Kind?: string; + + Value?: number; } diff --git a/src/models/GenericResourcesInnerNamedResourceSpec.ts b/src/models/GenericResourcesInnerNamedResourceSpec.ts index b394ee0..f052a6f 100644 --- a/src/models/GenericResourcesInnerNamedResourceSpec.ts +++ b/src/models/GenericResourcesInnerNamedResourceSpec.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class GenericResourcesInnerNamedResourceSpec { - 'Kind'?: string; - 'Value'?: string; +export interface GenericResourcesInnerNamedResourceSpec { + Kind?: string; + + Value?: string; } diff --git a/src/models/Health.ts b/src/models/Health.ts index 384e09e..440e6c6 100644 --- a/src/models/Health.ts +++ b/src/models/Health.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { HealthcheckResult } from '../models/HealthcheckResult.js'; @@ -15,24 +23,21 @@ import { HealthcheckResult } from '../models/HealthcheckResult.js'; /** * Health stores information about the container\'s healthcheck results. */ -export class Health { +export interface Health { /** - * Status is one of `none`, `starting`, `healthy` or `unhealthy` - \"none\" Indicates there is no healthcheck - \"starting\" Starting indicates that the container is not yet ready - \"healthy\" Healthy indicates that the container is running correctly - \"unhealthy\" Unhealthy indicates that the container has a problem + * Status is one of `none`, `starting`, `healthy` or `unhealthy` - \"none\" Indicates there is no healthcheck - \"starting\" Starting indicates that the container is not yet ready - \"healthy\" Healthy indicates that the container is running correctly - \"unhealthy\" Unhealthy indicates that the container has a problem */ - 'Status'?: HealthStatusEnum; + Status?: HealthStatusEnum; + /** * FailingStreak is the number of consecutive failures */ - 'FailingStreak'?: number; + FailingStreak?: number; + /** * Log contains the last few results (oldest first) */ - 'Log'?: Array; + Log?: Array; } -export enum HealthStatusEnum { - None = 'none', - Starting = 'starting', - Healthy = 'healthy', - Unhealthy = 'unhealthy', -} +export type HealthStatusEnum = 'none' | 'starting' | 'healthy' | 'unhealthy'; diff --git a/src/models/HealthConfig.ts b/src/models/HealthConfig.ts index b216ef6..362ab98 100644 --- a/src/models/HealthConfig.ts +++ b/src/models/HealthConfig.ts @@ -1,41 +1,54 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * A test to perform to check that the container is healthy. */ -export class HealthConfig { +export interface HealthConfig { /** - * The test to perform. Possible values are: - `[]` inherit healthcheck from image or parent image - `[\"NONE\"]` disable healthcheck - `[\"CMD\", args...]` exec arguments directly - `[\"CMD-SHELL\", command]` run command with system\'s default shell + * The test to perform. Possible values are: - `[]` inherit healthcheck from image or parent image - `[\"NONE\"]` disable healthcheck - `[\"CMD\", args...]` exec arguments directly - `[\"CMD-SHELL\", command]` run command with system\'s default shell */ - 'Test'?: Array; + Test?: Array; + /** * The time to wait between checks in nanoseconds. It should be 0 or at least 1000000 (1 ms). 0 means inherit. */ - 'Interval'?: number; + Interval?: number; + /** * The time to wait before considering the check to have hung. It should be 0 or at least 1000000 (1 ms). 0 means inherit. */ - 'Timeout'?: number; + Timeout?: number; + /** * The number of consecutive failures needed to consider a container as unhealthy. 0 means inherit. */ - 'Retries'?: number; + Retries?: number; + /** * Start period for the container to initialize before starting health-retries countdown in nanoseconds. It should be 0 or at least 1000000 (1 ms). 0 means inherit. */ - 'StartPeriod'?: number; + StartPeriod?: number; + /** * The time to wait between checks in nanoseconds during the start period. It should be 0 or at least 1000000 (1 ms). 0 means inherit. */ - 'StartInterval'?: number; + StartInterval?: number; } diff --git a/src/models/HealthcheckResult.ts b/src/models/HealthcheckResult.ts index 52a45f1..a19c676 100644 --- a/src/models/HealthcheckResult.ts +++ b/src/models/HealthcheckResult.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * HealthcheckResult stores information about a single run of a healthcheck probe */ -export class HealthcheckResult { +export interface HealthcheckResult { /** * Date and time at which this check started in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'Start'?: Date; + Start?: Date; + /** * Date and time at which this check ended in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'End'?: string; + End?: string; + /** - * ExitCode meanings: - `0` healthy - `1` unhealthy - `2` reserved (considered unhealthy) - other values: error running probe + * ExitCode meanings: - `0` healthy - `1` unhealthy - `2` reserved (considered unhealthy) - other values: error running probe */ - 'ExitCode'?: number; + ExitCode?: number; + /** * Output from last check */ - 'Output'?: string; + Output?: string; } diff --git a/src/models/HistoryResponseItem.ts b/src/models/HistoryResponseItem.ts index 0f8f706..72db96c 100644 --- a/src/models/HistoryResponseItem.ts +++ b/src/models/HistoryResponseItem.ts @@ -1,23 +1,36 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * individual image layer information in response to ImageHistory operation */ -export class HistoryResponseItem { - 'Id': string; - 'Created': number; - 'CreatedBy': string; - 'Tags': Array; - 'Size': number; - 'Comment': string; +export interface HistoryResponseItem { + Id: string; + + Created: number; + + CreatedBy: string; + + Tags: Array; + + Size: number; + + Comment: string; } diff --git a/src/models/HostConfig.ts b/src/models/HostConfig.ts index 56ddcf3..2bd079a 100644 --- a/src/models/HostConfig.ts +++ b/src/models/HostConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { DeviceMapping } from '../models/DeviceMapping.js'; @@ -23,290 +31,351 @@ import { ThrottleDevice } from '../models/ThrottleDevice.js'; /** * Container configuration that depends on the host we are running on */ -export class HostConfig { +export interface HostConfig { /** - * An integer value representing this container\'s relative CPU weight versus other containers. + * An integer value representing this container\'s relative CPU weight versus other containers. */ - 'CpuShares'?: number; + CpuShares?: number; + /** * Memory limit in bytes. */ - 'Memory'?: number; + Memory?: number; + /** - * Path to `cgroups` under which the container\'s `cgroup` is created. If the path is not absolute, the path is considered to be relative to the `cgroups` path of the init process. Cgroups are created if they do not already exist. + * Path to `cgroups` under which the container\'s `cgroup` is created. If the path is not absolute, the path is considered to be relative to the `cgroups` path of the init process. Cgroups are created if they do not already exist. */ - 'CgroupParent'?: string; + CgroupParent?: string; + /** * Block IO weight (relative weight). */ - 'BlkioWeight'?: number; + BlkioWeight?: number; + /** - * Block IO weight (relative device weight) in the form: ``` [{\"Path\": \"device_path\", \"Weight\": weight}] ``` + * Block IO weight (relative device weight) in the form: ``` [{\"Path\": \"device_path\", \"Weight\": weight}] ``` */ - 'BlkioWeightDevice'?: Array; + BlkioWeightDevice?: Array; + /** - * Limit read rate (bytes per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit read rate (bytes per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceReadBps'?: Array; + BlkioDeviceReadBps?: Array; + /** - * Limit write rate (bytes per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit write rate (bytes per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceWriteBps'?: Array; + BlkioDeviceWriteBps?: Array; + /** - * Limit read rate (IO per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit read rate (IO per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceReadIOps'?: Array; + BlkioDeviceReadIOps?: Array; + /** - * Limit write rate (IO per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit write rate (IO per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceWriteIOps'?: Array; + BlkioDeviceWriteIOps?: Array; + /** * The length of a CPU period in microseconds. */ - 'CpuPeriod'?: number; + CpuPeriod?: number; + /** * Microseconds of CPU time that the container can get in a CPU period. */ - 'CpuQuota'?: number; + CpuQuota?: number; + /** * The length of a CPU real-time period in microseconds. Set to 0 to allocate no time allocated to real-time tasks. */ - 'CpuRealtimePeriod'?: number; + CpuRealtimePeriod?: number; + /** * The length of a CPU real-time runtime in microseconds. Set to 0 to allocate no time allocated to real-time tasks. */ - 'CpuRealtimeRuntime'?: number; + CpuRealtimeRuntime?: number; + /** - * CPUs in which to allow execution (e.g., `0-3`, `0,1`). + * CPUs in which to allow execution (e.g., `0-3`, `0,1`). */ - 'CpusetCpus'?: string; + CpusetCpus?: string; + /** * Memory nodes (MEMs) in which to allow execution (0-3, 0,1). Only effective on NUMA systems. */ - 'CpusetMems'?: string; + CpusetMems?: string; + /** * A list of devices to add to the container. */ - 'Devices'?: Array; + Devices?: Array; + /** * a list of cgroup rules to apply to the container */ - 'DeviceCgroupRules'?: Array; + DeviceCgroupRules?: Array; + /** * A list of requests for devices to be sent to device drivers. */ - 'DeviceRequests'?: Array; + DeviceRequests?: Array; + /** * Hard limit for kernel TCP buffer memory (in bytes). Depending on the OCI runtime in use, this option may be ignored. It is no longer supported by the default (runc) runtime. This field is omitted when empty. */ - 'KernelMemoryTCP'?: number; + KernelMemoryTCP?: number; + /** * Memory soft limit in bytes. */ - 'MemoryReservation'?: number; + MemoryReservation?: number; + /** - * Total memory limit (memory + swap). Set as `-1` to enable unlimited swap. + * Total memory limit (memory + swap). Set as `-1` to enable unlimited swap. */ - 'MemorySwap'?: number; + MemorySwap?: number; + /** - * Tune a container\'s memory swappiness behavior. Accepts an integer between 0 and 100. + * Tune a container\'s memory swappiness behavior. Accepts an integer between 0 and 100. */ - 'MemorySwappiness'?: number; + MemorySwappiness?: number; + /** - * CPU quota in units of 10-9 CPUs. + * CPU quota in units of 10<sup>-9</sup> CPUs. */ - 'NanoCpus'?: number; + NanoCpus?: number; + /** * Disable OOM Killer for the container. */ - 'OomKillDisable'?: boolean; + OomKillDisable?: boolean; + /** * Run an init inside the container that forwards signals and reaps processes. This field is omitted if empty, and the default (as configured on the daemon) is used. */ - 'Init'?: boolean | null; + Init?: boolean | null; + /** - * Tune a container\'s PIDs limit. Set `0` or `-1` for unlimited, or `null` to not change. + * Tune a container\'s PIDs limit. Set `0` or `-1` for unlimited, or `null` to not change. */ - 'PidsLimit'?: number | null; + PidsLimit?: number | null; + /** - * A list of resource limits to set in the container. For example: ``` {\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048} ``` + * A list of resource limits to set in the container. For example: ``` {\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048} ``` */ - 'Ulimits'?: Array; + Ulimits?: Array; + /** - * The number of usable CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. + * The number of usable CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. */ - 'CpuCount'?: number; + CpuCount?: number; + /** - * The usable percentage of the available CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. + * The usable percentage of the available CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. */ - 'CpuPercent'?: number; + CpuPercent?: number; + /** * Maximum IOps for the container system drive (Windows only) */ - 'IOMaximumIOps'?: number; + IOMaximumIOps?: number; + /** * Maximum IO in bytes per second for the container system drive (Windows only). */ - 'IOMaximumBandwidth'?: number; + IOMaximumBandwidth?: number; + /** - * A list of volume bindings for this container. Each volume binding is a string in one of these forms: - `host-src:container-dest[:options]` to bind-mount a host path into the container. Both `host-src`, and `container-dest` must be an _absolute_ path. - `volume-name:container-dest[:options]` to bind-mount a volume managed by a volume driver into the container. `container-dest` must be an _absolute_ path. `options` is an optional, comma-delimited list of: - `nocopy` disables automatic copying of data from the container path to the volume. The `nocopy` flag only applies to named volumes. - `[ro|rw]` mounts a volume read-only or read-write, respectively. If omitted or set to `rw`, volumes are mounted read-write. - `[z|Z]` applies SELinux labels to allow or deny multiple containers to read and write to the same volume. - `z`: a _shared_ content label is applied to the content. This label indicates that multiple containers can share the volume content, for both reading and writing. - `Z`: a _private unshared_ label is applied to the content. This label indicates that only the current container can use a private volume. Labeling systems such as SELinux require proper labels to be placed on volume content that is mounted into a container. Without a label, the security system can prevent a container\'s processes from using the content. By default, the labels set by the host operating system are not modified. - `[[r]shared|[r]slave|[r]private]` specifies mount [propagation behavior](https://www.kernel.org/doc/Documentation/filesystems/sharedsubtree.txt). This only applies to bind-mounted volumes, not internal volumes or named volumes. Mount propagation requires the source mount point (the location where the source directory is mounted in the host operating system) to have the correct propagation properties. For shared volumes, the source mount point must be set to `shared`. For slave volumes, the mount must be set to either `shared` or `slave`. + * A list of volume bindings for this container. Each volume binding is a string in one of these forms: - `host-src:container-dest[:options]` to bind-mount a host path into the container. Both `host-src`, and `container-dest` must be an _absolute_ path. - `volume-name:container-dest[:options]` to bind-mount a volume managed by a volume driver into the container. `container-dest` must be an _absolute_ path. `options` is an optional, comma-delimited list of: - `nocopy` disables automatic copying of data from the container path to the volume. The `nocopy` flag only applies to named volumes. - `[ro|rw]` mounts a volume read-only or read-write, respectively. If omitted or set to `rw`, volumes are mounted read-write. - `[z|Z]` applies SELinux labels to allow or deny multiple containers to read and write to the same volume. - `z`: a _shared_ content label is applied to the content. This label indicates that multiple containers can share the volume content, for both reading and writing. - `Z`: a _private unshared_ label is applied to the content. This label indicates that only the current container can use a private volume. Labeling systems such as SELinux require proper labels to be placed on volume content that is mounted into a container. Without a label, the security system can prevent a container\'s processes from using the content. By default, the labels set by the host operating system are not modified. - `[[r]shared|[r]slave|[r]private]` specifies mount [propagation behavior](https://www.kernel.org/doc/Documentation/filesystems/sharedsubtree.txt). This only applies to bind-mounted volumes, not internal volumes or named volumes. Mount propagation requires the source mount point (the location where the source directory is mounted in the host operating system) to have the correct propagation properties. For shared volumes, the source mount point must be set to `shared`. For slave volumes, the mount must be set to either `shared` or `slave`. */ - 'Binds'?: Array; + Binds?: Array; + /** * Path to a file where the container ID is written */ - 'ContainerIDFile'?: string; - 'LogConfig'?: HostConfigAllOfLogConfig; + ContainerIDFile?: string; + + LogConfig?: HostConfigAllOfLogConfig; + /** - * Network mode to use for this container. Supported standard values are: `bridge`, `host`, `none`, and `container:`. Any other value is taken as a custom network\'s name to which this container should connect to. + * Network mode to use for this container. Supported standard values are: `bridge`, `host`, `none`, and `container:<name|id>`. Any other value is taken as a custom network\'s name to which this container should connect to. */ - 'NetworkMode'?: string; + NetworkMode?: string; + /** - * PortMap describes the mapping of container ports to host ports, using the container\'s port-number and protocol as key in the format `/`, for example, `80/udp`. If a container\'s port is mapped for multiple protocols, separate entries are added to the mapping table. + * PortMap describes the mapping of container ports to host ports, using the container\'s port-number and protocol as key in the format `<port>/<protocol>`, for example, `80/udp`. If a container\'s port is mapped for multiple protocols, separate entries are added to the mapping table. */ - 'PortBindings'?: { [key: string]: Array | null }; - 'RestartPolicy'?: RestartPolicy; + PortBindings?: { [key: string]: Array | null }; + + RestartPolicy?: RestartPolicy; + /** - * Automatically remove the container when the container\'s process exits. This has no effect if `RestartPolicy` is set. + * Automatically remove the container when the container\'s process exits. This has no effect if `RestartPolicy` is set. */ - 'AutoRemove'?: boolean; + AutoRemove?: boolean; + /** * Driver that this container uses to mount volumes. */ - 'VolumeDriver'?: string; + VolumeDriver?: string; + /** - * A list of volumes to inherit from another container, specified in the form `[:]`. + * A list of volumes to inherit from another container, specified in the form `<container name>[:<ro|rw>]`. */ - 'VolumesFrom'?: Array; + VolumesFrom?: Array; + /** * Specification for mounts to be added to the container. */ - 'Mounts'?: Array; + Mounts?: Array; + /** - * Initial console size, as an `[height, width]` array. + * Initial console size, as an `[height, width]` array. */ - 'ConsoleSize'?: Array | null; + ConsoleSize?: Array | null; + /** * Arbitrary non-identifying metadata attached to container and provided to the runtime when the container is started. */ - 'Annotations'?: { [key: string]: string }; + Annotations?: { [key: string]: string }; + /** - * A list of kernel capabilities to add to the container. Conflicts with option \'Capabilities\'. + * A list of kernel capabilities to add to the container. Conflicts with option \'Capabilities\'. */ - 'CapAdd'?: Array; + CapAdd?: Array; + /** - * A list of kernel capabilities to drop from the container. Conflicts with option \'Capabilities\'. + * A list of kernel capabilities to drop from the container. Conflicts with option \'Capabilities\'. */ - 'CapDrop'?: Array; + CapDrop?: Array; + /** - * cgroup namespace mode for the container. Possible values are: - `\"private\"`: the container runs in its own private cgroup namespace - `\"host\"`: use the host system\'s cgroup namespace If not specified, the daemon default is used, which can either be `\"private\"` or `\"host\"`, depending on daemon version, kernel support and configuration. + * cgroup namespace mode for the container. Possible values are: - `\"private\"`: the container runs in its own private cgroup namespace - `\"host\"`: use the host system\'s cgroup namespace If not specified, the daemon default is used, which can either be `\"private\"` or `\"host\"`, depending on daemon version, kernel support and configuration. */ - 'CgroupnsMode'?: HostConfigCgroupnsModeEnum; + CgroupnsMode?: HostConfigCgroupnsModeEnum; + /** * A list of DNS servers for the container to use. */ - 'Dns'?: Array; + Dns?: Array; + /** * A list of DNS options. */ - 'DnsOptions'?: Array; + DnsOptions?: Array; + /** * A list of DNS search domains. */ - 'DnsSearch'?: Array; + DnsSearch?: Array; + /** - * A list of hostnames/IP mappings to add to the container\'s `/etc/hosts` file. Specified in the form `[\"hostname:IP\"]`. + * A list of hostnames/IP mappings to add to the container\'s `/etc/hosts` file. Specified in the form `[\"hostname:IP\"]`. */ - 'ExtraHosts'?: Array; + ExtraHosts?: Array; + /** * A list of additional groups that the container process will run as. */ - 'GroupAdd'?: Array; + GroupAdd?: Array; + /** - * IPC sharing mode for the container. Possible values are: - `\"none\"`: own private IPC namespace, with /dev/shm not mounted - `\"private\"`: own private IPC namespace - `\"shareable\"`: own private IPC namespace, with a possibility to share it with other containers - `\"container:\"`: join another (shareable) container\'s IPC namespace - `\"host\"`: use the host system\'s IPC namespace If not specified, daemon default is used, which can either be `\"private\"` or `\"shareable\"`, depending on daemon version and configuration. + * IPC sharing mode for the container. Possible values are: - `\"none\"`: own private IPC namespace, with /dev/shm not mounted - `\"private\"`: own private IPC namespace - `\"shareable\"`: own private IPC namespace, with a possibility to share it with other containers - `\"container:<name|id>\"`: join another (shareable) container\'s IPC namespace - `\"host\"`: use the host system\'s IPC namespace If not specified, daemon default is used, which can either be `\"private\"` or `\"shareable\"`, depending on daemon version and configuration. */ - 'IpcMode'?: string; + IpcMode?: string; + /** * Cgroup to use for the container. */ - 'Cgroup'?: string; + Cgroup?: string; + /** - * A list of links for the container in the form `container_name:alias`. + * A list of links for the container in the form `container_name:alias`. */ - 'Links'?: Array; + Links?: Array; + /** * An integer value containing the score given to the container in order to tune OOM killer preferences. */ - 'OomScoreAdj'?: number; + OomScoreAdj?: number; + /** - * Set the PID (Process) Namespace mode for the container. It can be either: - `\"container:\"`: joins another container\'s PID namespace - `\"host\"`: use the host\'s PID namespace inside the container + * Set the PID (Process) Namespace mode for the container. It can be either: - `\"container:<name|id>\"`: joins another container\'s PID namespace - `\"host\"`: use the host\'s PID namespace inside the container */ - 'PidMode'?: string; + PidMode?: string; + /** * Gives the container full access to the host. */ - 'Privileged'?: boolean; + Privileged?: boolean; + /** - * Allocates an ephemeral host port for all of a container\'s exposed ports. Ports are de-allocated when the container stops and allocated when the container starts. The allocated port might be changed when restarting the container. The port is selected from the ephemeral port range that depends on the kernel. For example, on Linux the range is defined by `/proc/sys/net/ipv4/ip_local_port_range`. + * Allocates an ephemeral host port for all of a container\'s exposed ports. Ports are de-allocated when the container stops and allocated when the container starts. The allocated port might be changed when restarting the container. The port is selected from the ephemeral port range that depends on the kernel. For example, on Linux the range is defined by `/proc/sys/net/ipv4/ip_local_port_range`. */ - 'PublishAllPorts'?: boolean; + PublishAllPorts?: boolean; + /** - * Mount the container\'s root filesystem as read only. + * Mount the container\'s root filesystem as read only. */ - 'ReadonlyRootfs'?: boolean; + ReadonlyRootfs?: boolean; + /** * A list of string values to customize labels for MLS systems, such as SELinux. */ - 'SecurityOpt'?: Array; + SecurityOpt?: Array; + /** - * Storage driver options for this container, in the form `{\"size\": \"120G\"}`. + * Storage driver options for this container, in the form `{\"size\": \"120G\"}`. */ - 'StorageOpt'?: { [key: string]: string }; + StorageOpt?: { [key: string]: string }; + /** - * A map of container directories which should be replaced by tmpfs mounts, and their corresponding mount options. For example: ``` { \"/run\": \"rw,noexec,nosuid,size=65536k\" } ``` + * A map of container directories which should be replaced by tmpfs mounts, and their corresponding mount options. For example: ``` { \"/run\": \"rw,noexec,nosuid,size=65536k\" } ``` */ - 'Tmpfs'?: { [key: string]: string }; + Tmpfs?: { [key: string]: string }; + /** * UTS namespace to use for the container. */ - 'UTSMode'?: string; + UTSMode?: string; + /** * Sets the usernamespace mode for the container when usernamespace remapping option is enabled. */ - 'UsernsMode'?: string; + UsernsMode?: string; + /** - * Size of `/dev/shm` in bytes. If omitted, the system uses 64MB. + * Size of `/dev/shm` in bytes. If omitted, the system uses 64MB. */ - 'ShmSize'?: number; + ShmSize?: number; + /** * A list of kernel parameters (sysctls) to set in the container. This field is omitted if not set. */ - 'Sysctls'?: { [key: string]: string } | null; + Sysctls?: { [key: string]: string } | null; + /** * Runtime to use with this container. */ - 'Runtime'?: string | null; + Runtime?: string | null; + /** * Isolation technology of the container. (Windows only) */ - 'Isolation'?: HostConfigIsolationEnum; + Isolation?: HostConfigIsolationEnum; + /** * The list of paths to be masked inside the container (this overrides the default set of paths). */ - 'MaskedPaths'?: Array; + MaskedPaths?: Array; + /** * The list of paths to be set as read-only inside the container (this overrides the default set of paths). */ - 'ReadonlyPaths'?: Array; + ReadonlyPaths?: Array; } -export enum HostConfigCgroupnsModeEnum { - Private = 'private', - Host = 'host', -} -export enum HostConfigIsolationEnum { - Default = 'default', - Process = 'process', - Hyperv = 'hyperv', - Empty = '', -} +export type HostConfigCgroupnsModeEnum = 'private' | 'host'; +export type HostConfigIsolationEnum = 'default' | 'process' | 'hyperv' | ''; diff --git a/src/models/HostConfigAllOfLogConfig.ts b/src/models/HostConfigAllOfLogConfig.ts index 16e1807..7981af1 100644 --- a/src/models/HostConfigAllOfLogConfig.ts +++ b/src/models/HostConfigAllOfLogConfig.ts @@ -1,38 +1,46 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The logging configuration for this container */ -export class HostConfigAllOfLogConfig { +export interface HostConfigAllOfLogConfig { /** - * Name of the logging driver used for the container or \"none\" if logging is disabled. + * Name of the logging driver used for the container or \"none\" if logging is disabled. */ - 'Type'?: HostConfigAllOfLogConfigTypeEnum; + Type?: HostConfigAllOfLogConfigTypeEnum; + /** * Driver-specific configuration options for the logging driver. */ - 'Config'?: { [key: string]: string }; + Config?: { [key: string]: string }; } -export enum HostConfigAllOfLogConfigTypeEnum { - Local = 'local', - JsonFile = 'json-file', - Syslog = 'syslog', - Journald = 'journald', - Gelf = 'gelf', - Fluentd = 'fluentd', - Awslogs = 'awslogs', - Splunk = 'splunk', - Etwlogs = 'etwlogs', - None = 'none', -} +export type HostConfigAllOfLogConfigTypeEnum = + | 'local' + | 'json-file' + | 'syslog' + | 'journald' + | 'gelf' + | 'fluentd' + | 'awslogs' + | 'splunk' + | 'etwlogs' + | 'none'; diff --git a/src/models/IDResponse.ts b/src/models/IDResponse.ts index 085b7cc..6c4da3d 100644 --- a/src/models/IDResponse.ts +++ b/src/models/IDResponse.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Response to an API call that returns just an Id */ -export class IDResponse { +export interface IDResponse { /** * The id of the newly created object. */ - 'Id': string; + Id: string; } diff --git a/src/models/IPAM.ts b/src/models/IPAM.ts index f521603..fcfa398 100644 --- a/src/models/IPAM.ts +++ b/src/models/IPAM.ts @@ -1,28 +1,38 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { IPAMConfig } from '../models/IPAMConfig.js'; -export class IPAM { +export interface IPAM { /** * Name of the IPAM driver to use. */ - 'Driver'?: string; + Driver?: string; + /** - * List of IPAM configuration options, specified as a map: ``` {\"Subnet\": , \"IPRange\": , \"Gateway\": , \"AuxAddress\": } ``` + * List of IPAM configuration options, specified as a map: ``` {\"Subnet\": <CIDR>, \"IPRange\": <CIDR>, \"Gateway\": <IP address>, \"AuxAddress\": <device_name:IP address>} ``` */ - 'Config'?: Array; + Config?: Array; + /** * Driver-specific options, specified as a map. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; } diff --git a/src/models/IPAMConfig.ts b/src/models/IPAMConfig.ts index b0ca9cf..e75b9bd 100644 --- a/src/models/IPAMConfig.ts +++ b/src/models/IPAMConfig.ts @@ -1,18 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class IPAMConfig { - 'Subnet'?: string; - 'IPRange'?: string; - 'Gateway'?: string; - 'AuxiliaryAddresses'?: { [key: string]: string }; +export interface IPAMConfig { + Subnet?: string; + + IPRange?: string; + + Gateway?: string; + + AuxiliaryAddresses?: { [key: string]: string }; } diff --git a/src/models/ImageConfig.ts b/src/models/ImageConfig.ts index 8ed7370..559a117 100644 --- a/src/models/ImageConfig.ts +++ b/src/models/ImageConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { HealthConfig } from '../models/HealthConfig.js'; @@ -15,54 +23,66 @@ import { HealthConfig } from '../models/HealthConfig.js'; /** * Configuration of the image. These fields are used as defaults when starting a container from the image. */ -export class ImageConfig { +export interface ImageConfig { /** * The user that commands are run as inside the container. */ - 'User'?: string; + User?: string; + /** - * An object mapping ports to an empty object in the form: `{\"/\": {}}` + * An object mapping ports to an empty object in the form: `{\"<port>/<tcp|udp|sctp>\": {}}` */ - 'ExposedPorts'?: { [key: string]: any } | null; + ExposedPorts?: { [key: string]: any } | null; + /** - * A list of environment variables to set inside the container in the form `[\"VAR=value\", ...]`. A variable without `=` is removed from the environment, rather than to have an empty value. + * A list of environment variables to set inside the container in the form `[\"VAR=value\", ...]`. A variable without `=` is removed from the environment, rather than to have an empty value. */ - 'Env'?: Array; + Env?: Array; + /** * Command to run specified as a string or an array of strings. */ - 'Cmd'?: Array; - 'Healthcheck'?: HealthConfig; + Cmd?: Array; + + Healthcheck?: HealthConfig; + /** * Command is already escaped (Windows only) */ - 'ArgsEscaped'?: boolean | null; + ArgsEscaped?: boolean | null; + /** * An object mapping mount point paths inside the container to empty objects. */ - 'Volumes'?: { [key: string]: any }; + Volumes?: { [key: string]: any }; + /** * The working directory for commands to run in. */ - 'WorkingDir'?: string; + WorkingDir?: string; + /** - * The entry point for the container as a string or an array of strings. If the array consists of exactly one empty string (`[\"\"]`) then the entry point is reset to system default (i.e., the entry point used by docker when there is no `ENTRYPOINT` instruction in the `Dockerfile`). + * The entry point for the container as a string or an array of strings. If the array consists of exactly one empty string (`[\"\"]`) then the entry point is reset to system default (i.e., the entry point used by docker when there is no `ENTRYPOINT` instruction in the `Dockerfile`). */ - 'Entrypoint'?: Array; + Entrypoint?: Array; + /** - * `ONBUILD` metadata that were defined in the image\'s `Dockerfile`. + * `ONBUILD` metadata that were defined in the image\'s `Dockerfile`. */ - 'OnBuild'?: Array | null; + OnBuild?: Array | null; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Signal to stop a container as a string or unsigned integer. */ - 'StopSignal'?: string | null; + StopSignal?: string | null; + /** - * Shell for when `RUN`, `CMD`, and `ENTRYPOINT` uses a shell. + * Shell for when `RUN`, `CMD`, and `ENTRYPOINT` uses a shell. */ - 'Shell'?: Array | null; + Shell?: Array | null; } diff --git a/src/models/ImageDeleteResponseItem.ts b/src/models/ImageDeleteResponseItem.ts index f3b94a0..6c1e403 100644 --- a/src/models/ImageDeleteResponseItem.ts +++ b/src/models/ImageDeleteResponseItem.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ImageDeleteResponseItem { +export interface ImageDeleteResponseItem { /** * The image ID of an image that was untagged */ - 'Untagged'?: string; + Untagged?: string; + /** * The image ID of an image that was deleted */ - 'Deleted'?: string; + Deleted?: string; } diff --git a/src/models/ImageID.ts b/src/models/ImageID.ts index 6d49086..f292e87 100644 --- a/src/models/ImageID.ts +++ b/src/models/ImageID.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Image ID or Digest */ -export class ImageID { - 'ID'?: string; +export interface ImageID { + ID?: string; } diff --git a/src/models/ImageInspect.ts b/src/models/ImageInspect.ts index 398329b..5858c95 100644 --- a/src/models/ImageInspect.ts +++ b/src/models/ImageInspect.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { DriverData } from '../models/DriverData.js'; @@ -20,70 +28,89 @@ import { OCIDescriptor } from '../models/OCIDescriptor.js'; /** * Information about an image in the local image cache. */ -export class ImageInspect { +export interface ImageInspect { /** - * ID is the content-addressable ID of an image. This identifier is a content-addressable digest calculated from the image\'s configuration (which includes the digests of layers used by the image). Note that this digest differs from the `RepoDigests` below, which holds digests of image manifests that reference the image. + * ID is the content-addressable ID of an image. This identifier is a content-addressable digest calculated from the image\'s configuration (which includes the digests of layers used by the image). Note that this digest differs from the `RepoDigests` below, which holds digests of image manifests that reference the image. */ - 'Id'?: string; - 'Descriptor'?: OCIDescriptor; + Id?: string; + + Descriptor?: OCIDescriptor; + /** - * Manifests is a list of image manifests available in this image. It provides a more detailed view of the platform-specific image manifests or other image-attached data like build attestations. Only available if the daemon provides a multi-platform image store and the `manifests` option is set in the inspect request. WARNING: This is experimental and may change at any time without any backward compatibility. + * Manifests is a list of image manifests available in this image. It provides a more detailed view of the platform-specific image manifests or other image-attached data like build attestations. Only available if the daemon provides a multi-platform image store and the `manifests` option is set in the inspect request. WARNING: This is experimental and may change at any time without any backward compatibility. */ - 'Manifests'?: Array | null; + Manifests?: Array | null; + /** - * List of image names/tags in the local image cache that reference this image. Multiple image tags can refer to the same image, and this list may be empty if no tags reference the image, in which case the image is \"untagged\", in which case it can still be referenced by its ID. + * List of image names/tags in the local image cache that reference this image. Multiple image tags can refer to the same image, and this list may be empty if no tags reference the image, in which case the image is \"untagged\", in which case it can still be referenced by its ID. */ - 'RepoTags'?: Array; + RepoTags?: Array; + /** * List of content-addressable digests of locally available image manifests that the image is referenced from. Multiple manifests can refer to the same image. These digests are usually only available if the image was either pulled from a registry, or if the image was pushed to a registry, which is when the manifest is generated and its digest calculated. */ - 'RepoDigests'?: Array; + RepoDigests?: Array; + /** * ID of the parent image. Depending on how the image was created, this field may be empty and is only set for images that were built/created locally. This field is empty if the image was pulled from an image registry. */ - 'Parent'?: string; + Parent?: string; + /** * Optional message that was set when committing or importing the image. */ - 'Comment'?: string; + Comment?: string; + /** * Date and time at which the image was created, formatted in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. This information is only available if present in the image, and omitted otherwise. */ - 'Created'?: string | null; + Created?: string | null; + /** * The version of Docker that was used to build the image. Depending on how the image was created, this field may be empty. */ - 'DockerVersion'?: string; + DockerVersion?: string; + /** * Name of the author that was specified when committing the image, or as specified through MAINTAINER (deprecated) in the Dockerfile. */ - 'Author'?: string; - 'Config'?: ImageConfig; + Author?: string; + + Config?: ImageConfig; + /** * Hardware CPU architecture that the image runs on. */ - 'Architecture'?: string; + Architecture?: string; + /** * CPU architecture variant (presently ARM-only). */ - 'Variant'?: string | null; + Variant?: string | null; + /** * Operating System the image is built to run on. */ - 'Os'?: string; + Os?: string; + /** * Operating System version the image is built to run on (especially for Windows). */ - 'OsVersion'?: string | null; + OsVersion?: string | null; + /** * Total size of the image including all layers it is composed of. */ - 'Size'?: number; + Size?: number; + /** * Total size of the image including all layers it is composed of. Deprecated: this field is omitted in API v1.44, but kept for backward compatibility. Use Size instead. */ - 'VirtualSize'?: number; - 'GraphDriver'?: DriverData; - 'RootFS'?: ImageInspectRootFS; - 'Metadata'?: ImageInspectMetadata; + VirtualSize?: number; + + GraphDriver?: DriverData; + + RootFS?: ImageInspectRootFS; + + Metadata?: ImageInspectMetadata; } diff --git a/src/models/ImageInspectMetadata.ts b/src/models/ImageInspectMetadata.ts index c3e2d1d..2cad8d5 100644 --- a/src/models/ImageInspectMetadata.ts +++ b/src/models/ImageInspectMetadata.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Additional metadata of the image in the local cache. This information is local to the daemon, and not part of the image itself. */ -export class ImageInspectMetadata { +export interface ImageInspectMetadata { /** * Date and time at which the image was last tagged in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. This information is only available if the image was tagged locally, and omitted otherwise. */ - 'LastTagTime'?: string | null; + LastTagTime?: string | null; } diff --git a/src/models/ImageInspectRootFS.ts b/src/models/ImageInspectRootFS.ts index 7fd31b3..de5f6e8 100644 --- a/src/models/ImageInspectRootFS.ts +++ b/src/models/ImageInspectRootFS.ts @@ -1,19 +1,28 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Information about the image\'s RootFS, including the layer IDs. */ -export class ImageInspectRootFS { - 'Type': string; - 'Layers'?: Array; +export interface ImageInspectRootFS { + Type: string; + + Layers?: Array; } diff --git a/src/models/ImageManifestSummary.ts b/src/models/ImageManifestSummary.ts index 082da4d..41ae941 100644 --- a/src/models/ImageManifestSummary.ts +++ b/src/models/ImageManifestSummary.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ImageManifestSummaryAttestationData } from '../models/ImageManifestSummaryAttestationData.js'; @@ -18,27 +26,29 @@ import { OCIDescriptor } from '../models/OCIDescriptor.js'; /** * ImageManifestSummary represents a summary of an image manifest. */ -export class ImageManifestSummary { +export interface ImageManifestSummary { /** * ID is the content-addressable ID of an image and is the same as the digest of the image manifest. */ - 'ID': string; - 'Descriptor': OCIDescriptor; + ID: string; + + Descriptor: OCIDescriptor; + /** * Indicates whether all the child content (image config, layers) is fully available locally. */ - 'Available': boolean; - 'Size': ImageManifestSummarySize; + Available: boolean; + + Size: ImageManifestSummarySize; + /** * The kind of the manifest. kind | description -------------|----------------------------------------------------------- image | Image manifest that can be used to start a container. attestation | Attestation manifest produced by the Buildkit builder for a specific image manifest. */ - 'Kind': ImageManifestSummaryKindEnum; - 'ImageData'?: ImageManifestSummaryImageData | null; - 'AttestationData'?: ImageManifestSummaryAttestationData | null; -} + Kind: ImageManifestSummaryKindEnum; + + ImageData?: ImageManifestSummaryImageData | null; -export enum ImageManifestSummaryKindEnum { - Image = 'image', - Attestation = 'attestation', - Unknown = 'unknown', + AttestationData?: ImageManifestSummaryAttestationData | null; } + +export type ImageManifestSummaryKindEnum = 'image' | 'attestation' | 'unknown'; diff --git a/src/models/ImageManifestSummaryAttestationData.ts b/src/models/ImageManifestSummaryAttestationData.ts index dd429d1..68889ba 100644 --- a/src/models/ImageManifestSummaryAttestationData.ts +++ b/src/models/ImageManifestSummaryAttestationData.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The image data for the attestation manifest. This field is only populated when Kind is \"attestation\". */ -export class ImageManifestSummaryAttestationData { +export interface ImageManifestSummaryAttestationData { /** * The digest of the image manifest that this attestation is for. */ - '_for': string; + _for: string; } diff --git a/src/models/ImageManifestSummaryImageData.ts b/src/models/ImageManifestSummaryImageData.ts index 3e402da..c39e1aa 100644 --- a/src/models/ImageManifestSummaryImageData.ts +++ b/src/models/ImageManifestSummaryImageData.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ImageManifestSummaryImageDataSize } from '../models/ImageManifestSummaryImageDataSize.js'; @@ -16,11 +24,13 @@ import { OCIPlatform } from '../models/OCIPlatform.js'; /** * The image data for the image manifest. This field is only populated when Kind is \"image\". */ -export class ImageManifestSummaryImageData { - 'Platform': OCIPlatform | null; +export interface ImageManifestSummaryImageData { + Platform: OCIPlatform | null; + /** * The IDs of the containers that are using this image. */ - 'Containers': Array; - 'Size': ImageManifestSummaryImageDataSize; + Containers: Array; + + Size: ImageManifestSummaryImageDataSize; } diff --git a/src/models/ImageManifestSummaryImageDataSize.ts b/src/models/ImageManifestSummaryImageDataSize.ts index f317432..57801bf 100644 --- a/src/models/ImageManifestSummaryImageDataSize.ts +++ b/src/models/ImageManifestSummaryImageDataSize.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ImageManifestSummaryImageDataSize { +export interface ImageManifestSummaryImageDataSize { /** - * Unpacked is the size (in bytes) of the locally unpacked (uncompressed) image content that\'s directly usable by the containers running this image. It\'s independent of the distributable content - e.g. the image might still have an unpacked data that\'s still used by some container even when the distributable/compressed content is already gone. + * Unpacked is the size (in bytes) of the locally unpacked (uncompressed) image content that\'s directly usable by the containers running this image. It\'s independent of the distributable content - e.g. the image might still have an unpacked data that\'s still used by some container even when the distributable/compressed content is already gone. */ - 'Unpacked': number; + Unpacked: number; } diff --git a/src/models/ImageManifestSummarySize.ts b/src/models/ImageManifestSummarySize.ts index f9c950e..fdf6225 100644 --- a/src/models/ImageManifestSummarySize.ts +++ b/src/models/ImageManifestSummarySize.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ImageManifestSummarySize { +export interface ImageManifestSummarySize { /** - * Total is the total size (in bytes) of all the locally present data (both distributable and non-distributable) that\'s related to this manifest and its children. This equal to the sum of [Content] size AND all the sizes in the [Size] struct present in the Kind-specific data struct. For example, for an image kind (Kind == \"image\") this would include the size of the image content and unpacked image snapshots ([Size.Content] + [ImageData.Size.Unpacked]). + * Total is the total size (in bytes) of all the locally present data (both distributable and non-distributable) that\'s related to this manifest and its children. This equal to the sum of [Content] size AND all the sizes in the [Size] struct present in the Kind-specific data struct. For example, for an image kind (Kind == \"image\") this would include the size of the image content and unpacked image snapshots ([Size.Content] + [ImageData.Size.Unpacked]). */ - 'Total': number; + Total: number; + /** * Content is the size (in bytes) of all the locally present content in the content store (e.g. image config, layers) referenced by this manifest and its children. This only includes blobs in the content store. */ - 'Content': number; + Content: number; } diff --git a/src/models/ImagePruneResponse.ts b/src/models/ImagePruneResponse.ts index 4c08be8..77b439e 100644 --- a/src/models/ImagePruneResponse.ts +++ b/src/models/ImagePruneResponse.ts @@ -1,24 +1,33 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ImageDeleteResponseItem } from '../models/ImageDeleteResponseItem.js'; -export class ImagePruneResponse { +export interface ImagePruneResponse { /** * Images that were deleted */ - 'ImagesDeleted'?: Array; + ImagesDeleted?: Array; + /** * Disk space reclaimed in bytes */ - 'SpaceReclaimed'?: number; + SpaceReclaimed?: number; } diff --git a/src/models/ImageSearchResponseItem.ts b/src/models/ImageSearchResponseItem.ts index 46f669c..04e70c9 100644 --- a/src/models/ImageSearchResponseItem.ts +++ b/src/models/ImageSearchResponseItem.ts @@ -1,22 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ImageSearchResponseItem { - 'Description'?: string; - 'IsOfficial'?: boolean; +export interface ImageSearchResponseItem { + Description?: string; + + IsOfficial?: boolean; + /** - * Whether this repository has automated builds enabled.


> **Deprecated**: This field is deprecated and will always be \"false\". + * Whether this repository has automated builds enabled. <p><br /></p> > **Deprecated**: This field is deprecated and will always be \"false\". */ - 'IsAutomated'?: boolean; - 'Name'?: string; - 'StarCount'?: number; + IsAutomated?: boolean; + + Name?: string; + + StarCount?: number; } diff --git a/src/models/ImageSummary.ts b/src/models/ImageSummary.ts index 7a16c62..87077bc 100644 --- a/src/models/ImageSummary.ts +++ b/src/models/ImageSummary.ts @@ -1,62 +1,81 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ImageManifestSummary } from '../models/ImageManifestSummary.js'; import { OCIDescriptor } from '../models/OCIDescriptor.js'; -export class ImageSummary { +export interface ImageSummary { /** - * ID is the content-addressable ID of an image. This identifier is a content-addressable digest calculated from the image\'s configuration (which includes the digests of layers used by the image). Note that this digest differs from the `RepoDigests` below, which holds digests of image manifests that reference the image. + * ID is the content-addressable ID of an image. This identifier is a content-addressable digest calculated from the image\'s configuration (which includes the digests of layers used by the image). Note that this digest differs from the `RepoDigests` below, which holds digests of image manifests that reference the image. */ - 'Id': string; + Id: string; + /** * ID of the parent image. Depending on how the image was created, this field may be empty and is only set for images that were built/created locally. This field is empty if the image was pulled from an image registry. */ - 'ParentId': string; + ParentId: string; + /** - * List of image names/tags in the local image cache that reference this image. Multiple image tags can refer to the same image, and this list may be empty if no tags reference the image, in which case the image is \"untagged\", in which case it can still be referenced by its ID. + * List of image names/tags in the local image cache that reference this image. Multiple image tags can refer to the same image, and this list may be empty if no tags reference the image, in which case the image is \"untagged\", in which case it can still be referenced by its ID. */ - 'RepoTags': Array; + RepoTags: Array; + /** * List of content-addressable digests of locally available image manifests that the image is referenced from. Multiple manifests can refer to the same image. These digests are usually only available if the image was either pulled from a registry, or if the image was pushed to a registry, which is when the manifest is generated and its digest calculated. */ - 'RepoDigests': Array; + RepoDigests: Array; + /** * Date and time at which the image was created as a Unix timestamp (number of seconds since EPOCH). */ - 'Created': number; + Created: number; + /** * Total size of the image including all layers it is composed of. */ - 'Size': number; + Size: number; + /** - * Total size of image layers that are shared between this image and other images. This size is not calculated by default. `-1` indicates that the value has not been set / calculated. + * Total size of image layers that are shared between this image and other images. This size is not calculated by default. `-1` indicates that the value has not been set / calculated. */ - 'SharedSize': number; + SharedSize: number; + /** * Total size of the image including all layers it is composed of. Deprecated: this field is omitted in API v1.44, but kept for backward compatibility. Use Size instead. */ - 'VirtualSize'?: number; + VirtualSize?: number; + /** * User-defined key/value metadata. */ - 'Labels': { [key: string]: string }; + Labels: { [key: string]: string }; + /** - * Number of containers using this image. Includes both stopped and running containers. `-1` indicates that the value has not been set / calculated. + * Number of containers using this image. Includes both stopped and running containers. `-1` indicates that the value has not been set / calculated. */ - 'Containers': number; + Containers: number; + /** * Manifests is a list of manifests available in this image. It provides a more detailed view of the platform-specific image manifests or other image-attached data like build attestations. WARNING: This is experimental and may change at any time without any backward compatibility. */ - 'Manifests'?: Array; - 'Descriptor'?: OCIDescriptor; + Manifests?: Array; + + Descriptor?: OCIDescriptor; } diff --git a/src/models/IndexInfo.ts b/src/models/IndexInfo.ts index 12fdbe2..785ac5a 100644 --- a/src/models/IndexInfo.ts +++ b/src/models/IndexInfo.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * IndexInfo contains information about a registry. */ -export class IndexInfo { +export interface IndexInfo { /** - * Name of the registry, such as \"docker.io\". + * Name of the registry, such as \"docker.io\". */ - 'Name'?: string; + Name?: string; + /** * List of mirrors, expressed as URIs. */ - 'Mirrors'?: Array; + Mirrors?: Array; + /** - * Indicates if the registry is part of the list of insecure registries. If `false`, the registry is insecure. Insecure registries accept un-encrypted (HTTP) and/or untrusted (HTTPS with certificates from unknown CAs) communication. > **Warning**: Insecure registries can be useful when running a local > registry. However, because its use creates security vulnerabilities > it should ONLY be enabled for testing purposes. For increased > security, users should add their CA to their system\'s list of > trusted CAs instead of enabling this option. + * Indicates if the registry is part of the list of insecure registries. If `false`, the registry is insecure. Insecure registries accept un-encrypted (HTTP) and/or untrusted (HTTPS with certificates from unknown CAs) communication. > **Warning**: Insecure registries can be useful when running a local > registry. However, because its use creates security vulnerabilities > it should ONLY be enabled for testing purposes. For increased > security, users should add their CA to their system\'s list of > trusted CAs instead of enabling this option. */ - 'Secure'?: boolean; + Secure?: boolean; + /** * Indicates whether this is an official registry (i.e., Docker Hub / docker.io) */ - 'Official'?: boolean; + Official?: boolean; } diff --git a/src/models/JoinTokens.ts b/src/models/JoinTokens.ts index df97b20..2fb32d6 100644 --- a/src/models/JoinTokens.ts +++ b/src/models/JoinTokens.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * JoinTokens contains the tokens workers and managers need to join the swarm. */ -export class JoinTokens { +export interface JoinTokens { /** * The token workers can use to join the swarm. */ - 'Worker'?: string; + Worker?: string; + /** * The token managers can use to join the swarm. */ - 'Manager'?: string; + Manager?: string; } diff --git a/src/models/Limit.ts b/src/models/Limit.ts index b40f9f9..2c27b2f 100644 --- a/src/models/Limit.ts +++ b/src/models/Limit.ts @@ -1,23 +1,33 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * An object describing a limit on resources which can be requested by a task. */ -export class Limit { - 'NanoCPUs'?: number; - 'MemoryBytes'?: number; +export interface Limit { + NanoCPUs?: number; + + MemoryBytes?: number; + /** - * Limits the maximum number of PIDs in the container. Set `0` for unlimited. + * Limits the maximum number of PIDs in the container. Set `0` for unlimited. */ - 'Pids'?: number; + Pids?: number; } diff --git a/src/models/LocalNodeState.ts b/src/models/LocalNodeState.ts index 2a5dff5..7bddf0d 100644 --- a/src/models/LocalNodeState.ts +++ b/src/models/LocalNodeState.ts @@ -1,23 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Current local status of this node. */ -export enum LocalNodeState { - Empty = '', - Inactive = 'inactive', - Pending = 'pending', - Active = 'active', - Error = 'error', - Locked = 'locked', -} +export type LocalNodeState = + | '' + | 'inactive' + | 'pending' + | 'active' + | 'error' + | 'locked'; diff --git a/src/models/ManagerStatus.ts b/src/models/ManagerStatus.ts index 56ec958..050f541 100644 --- a/src/models/ManagerStatus.ts +++ b/src/models/ManagerStatus.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Reachability } from '../models/Reachability.js'; @@ -15,11 +23,13 @@ import { Reachability } from '../models/Reachability.js'; /** * ManagerStatus represents the status of a manager. It provides the current status of a node\'s manager component, if the node is a manager. */ -export class ManagerStatus { - 'Leader'?: boolean; - 'Reachability'?: Reachability; +export interface ManagerStatus { + Leader?: boolean; + + Reachability?: Reachability; + /** * The IP address and port at which the manager is reachable. */ - 'Addr'?: string; + Addr?: string; } diff --git a/src/models/Mount.ts b/src/models/Mount.ts index 2b71461..1ffe5e7 100644 --- a/src/models/Mount.ts +++ b/src/models/Mount.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { MountBindOptions } from '../models/MountBindOptions.js'; @@ -15,38 +23,45 @@ import { MountImageOptions } from '../models/MountImageOptions.js'; import { MountTmpfsOptions } from '../models/MountTmpfsOptions.js'; import { MountVolumeOptions } from '../models/MountVolumeOptions.js'; -export class Mount { +export interface Mount { /** * Container path. */ - 'Target'?: string; + Target?: string; + /** * Mount source (e.g. a volume name, a host path). */ - 'Source'?: string; + Source?: string; + /** - * The mount type. Available types: - `bind` Mounts a file or directory from the host into the container. Must exist prior to creating the container. - `volume` Creates a volume with the given name and options (or uses a pre-existing volume with the same name and options). These are **not** removed when the container is removed. - `image` Mounts an image. - `tmpfs` Create a tmpfs with the given options. The mount source cannot be specified for tmpfs. - `npipe` Mounts a named pipe from the host into the container. Must exist prior to creating the container. - `cluster` a Swarm cluster volume + * The mount type. Available types: - `bind` Mounts a file or directory from the host into the container. Must exist prior to creating the container. - `volume` Creates a volume with the given name and options (or uses a pre-existing volume with the same name and options). These are **not** removed when the container is removed. - `image` Mounts an image. - `tmpfs` Create a tmpfs with the given options. The mount source cannot be specified for tmpfs. - `npipe` Mounts a named pipe from the host into the container. Must exist prior to creating the container. - `cluster` a Swarm cluster volume */ - 'Type'?: MountTypeEnum; + Type?: MountTypeEnum; + /** * Whether the mount should be read-only. */ - 'ReadOnly'?: boolean; + ReadOnly?: boolean; + /** - * The consistency requirement for the mount: `default`, `consistent`, `cached`, or `delegated`. + * The consistency requirement for the mount: `default`, `consistent`, `cached`, or `delegated`. */ - 'Consistency'?: string; - 'BindOptions'?: MountBindOptions; - 'VolumeOptions'?: MountVolumeOptions; - 'ImageOptions'?: MountImageOptions; - 'TmpfsOptions'?: MountTmpfsOptions; -} + Consistency?: string; + + BindOptions?: MountBindOptions; -export enum MountTypeEnum { - Bind = 'bind', - Volume = 'volume', - Image = 'image', - Tmpfs = 'tmpfs', - Npipe = 'npipe', - Cluster = 'cluster', + VolumeOptions?: MountVolumeOptions; + + ImageOptions?: MountImageOptions; + + TmpfsOptions?: MountTmpfsOptions; } + +export type MountTypeEnum = + | 'bind' + | 'volume' + | 'image' + | 'tmpfs' + | 'npipe' + | 'cluster'; diff --git a/src/models/MountBindOptions.ts b/src/models/MountBindOptions.ts index 32d38d0..86f2aae 100644 --- a/src/models/MountBindOptions.ts +++ b/src/models/MountBindOptions.ts @@ -1,46 +1,57 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Optional configuration for the `bind` type. */ -export class MountBindOptions { +export interface MountBindOptions { /** - * A propagation mode with the value `[r]private`, `[r]shared`, or `[r]slave`. + * A propagation mode with the value `[r]private`, `[r]shared`, or `[r]slave`. */ - 'Propagation'?: MountBindOptionsPropagationEnum; + Propagation?: MountBindOptionsPropagationEnum; + /** * Disable recursive bind mount. */ - 'NonRecursive'?: boolean; + NonRecursive?: boolean; + /** * Create mount point on host if missing */ - 'CreateMountpoint'?: boolean; + CreateMountpoint?: boolean; + /** - * Make the mount non-recursively read-only, but still leave the mount recursive (unless NonRecursive is set to `true` in conjunction). Added in v1.44, before that version all read-only mounts were non-recursive by default. To match the previous behaviour this will default to `true` for clients on versions prior to v1.44. + * Make the mount non-recursively read-only, but still leave the mount recursive (unless NonRecursive is set to `true` in conjunction). Added in v1.44, before that version all read-only mounts were non-recursive by default. To match the previous behaviour this will default to `true` for clients on versions prior to v1.44. */ - 'ReadOnlyNonRecursive'?: boolean; + ReadOnlyNonRecursive?: boolean; + /** * Raise an error if the mount cannot be made recursively read-only. */ - 'ReadOnlyForceRecursive'?: boolean; + ReadOnlyForceRecursive?: boolean; } -export enum MountBindOptionsPropagationEnum { - Private = 'private', - Rprivate = 'rprivate', - Shared = 'shared', - Rshared = 'rshared', - Slave = 'slave', - Rslave = 'rslave', -} +export type MountBindOptionsPropagationEnum = + | 'private' + | 'rprivate' + | 'shared' + | 'rshared' + | 'slave' + | 'rslave'; diff --git a/src/models/MountImageOptions.ts b/src/models/MountImageOptions.ts index 1f68133..1a1595e 100644 --- a/src/models/MountImageOptions.ts +++ b/src/models/MountImageOptions.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Optional configuration for the `image` type. */ -export class MountImageOptions { +export interface MountImageOptions { /** * Source path inside the image. Must be relative without any back traversals. */ - 'Subpath'?: string; + Subpath?: string; } diff --git a/src/models/MountPoint.ts b/src/models/MountPoint.ts index cc9916c..206da1f 100644 --- a/src/models/MountPoint.ts +++ b/src/models/MountPoint.ts @@ -1,58 +1,72 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * MountPoint represents a mount point configuration inside the container. This is used for reporting the mountpoints in use by a container. */ -export class MountPoint { +export interface MountPoint { /** - * The mount type: - `bind` a mount of a file or directory from the host into the container. - `volume` a docker volume with the given `Name`. - `image` a docker image - `tmpfs` a `tmpfs`. - `npipe` a named pipe from the host into the container. - `cluster` a Swarm cluster volume + * The mount type: - `bind` a mount of a file or directory from the host into the container. - `volume` a docker volume with the given `Name`. - `image` a docker image - `tmpfs` a `tmpfs`. - `npipe` a named pipe from the host into the container. - `cluster` a Swarm cluster volume */ - 'Type'?: MountPointTypeEnum; + Type?: MountPointTypeEnum; + /** - * Name is the name reference to the underlying data defined by `Source` e.g., the volume name. + * Name is the name reference to the underlying data defined by `Source` e.g., the volume name. */ - 'Name'?: string; + Name?: string; + /** - * Source location of the mount. For volumes, this contains the storage location of the volume (within `/var/lib/docker/volumes/`). For bind-mounts, and `npipe`, this contains the source (host) part of the bind-mount. For `tmpfs` mount points, this field is empty. + * Source location of the mount. For volumes, this contains the storage location of the volume (within `/var/lib/docker/volumes/`). For bind-mounts, and `npipe`, this contains the source (host) part of the bind-mount. For `tmpfs` mount points, this field is empty. */ - 'Source'?: string; + Source?: string; + /** - * Destination is the path relative to the container root (`/`) where the `Source` is mounted inside the container. + * Destination is the path relative to the container root (`/`) where the `Source` is mounted inside the container. */ - 'Destination'?: string; + Destination?: string; + /** * Driver is the volume driver used to create the volume (if it is a volume). */ - 'Driver'?: string; + Driver?: string; + /** - * Mode is a comma separated list of options supplied by the user when creating the bind/volume mount. The default is platform-specific (`\"z\"` on Linux, empty on Windows). + * Mode is a comma separated list of options supplied by the user when creating the bind/volume mount. The default is platform-specific (`\"z\"` on Linux, empty on Windows). */ - 'Mode'?: string; + Mode?: string; + /** * Whether the mount is mounted writable (read-write). */ - 'RW'?: boolean; + RW?: boolean; + /** * Propagation describes how mounts are propagated from the host into the mount point, and vice-versa. Refer to the [Linux kernel documentation](https://www.kernel.org/doc/Documentation/filesystems/sharedsubtree.txt) for details. This field is not used on Windows. */ - 'Propagation'?: string; + Propagation?: string; } -export enum MountPointTypeEnum { - Bind = 'bind', - Volume = 'volume', - Image = 'image', - Tmpfs = 'tmpfs', - Npipe = 'npipe', - Cluster = 'cluster', -} +export type MountPointTypeEnum = + | 'bind' + | 'volume' + | 'image' + | 'tmpfs' + | 'npipe' + | 'cluster'; diff --git a/src/models/MountTmpfsOptions.ts b/src/models/MountTmpfsOptions.ts index e1e1a57..cab9f70 100644 --- a/src/models/MountTmpfsOptions.ts +++ b/src/models/MountTmpfsOptions.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Optional configuration for the `tmpfs` type. */ -export class MountTmpfsOptions { +export interface MountTmpfsOptions { /** * The size for the tmpfs mount in bytes. */ - 'SizeBytes'?: number; + SizeBytes?: number; + /** * The permission mode for the tmpfs mount in an integer. */ - 'Mode'?: number; + Mode?: number; + /** * The options to be passed to the tmpfs mount. An array of arrays. Flag options should be provided as 1-length arrays. Other types should be provided as as 2-length arrays, where the first item is the key and the second the value. */ - 'Options'?: Array>; + Options?: Array>; } diff --git a/src/models/MountVolumeOptions.ts b/src/models/MountVolumeOptions.ts index 9eda653..43d61d3 100644 --- a/src/models/MountVolumeOptions.ts +++ b/src/models/MountVolumeOptions.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { MountVolumeOptionsDriverConfig } from '../models/MountVolumeOptionsDriverConfig.js'; @@ -15,18 +23,21 @@ import { MountVolumeOptionsDriverConfig } from '../models/MountVolumeOptionsDriv /** * Optional configuration for the `volume` type. */ -export class MountVolumeOptions { +export interface MountVolumeOptions { /** * Populate volume with data from the target. */ - 'NoCopy'?: boolean; + NoCopy?: boolean; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'DriverConfig'?: MountVolumeOptionsDriverConfig; + Labels?: { [key: string]: string }; + + DriverConfig?: MountVolumeOptionsDriverConfig; + /** * Source path inside the volume. Must be relative without any back traversals. */ - 'Subpath'?: string; + Subpath?: string; } diff --git a/src/models/MountVolumeOptionsDriverConfig.ts b/src/models/MountVolumeOptionsDriverConfig.ts index 7be69e8..e300999 100644 --- a/src/models/MountVolumeOptionsDriverConfig.ts +++ b/src/models/MountVolumeOptionsDriverConfig.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Map of driver specific options */ -export class MountVolumeOptionsDriverConfig { +export interface MountVolumeOptionsDriverConfig { /** * Name of the driver to use to create the volume. */ - 'Name'?: string; + Name?: string; + /** * key/value map of driver specific options. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; } diff --git a/src/models/Network.ts b/src/models/Network.ts index 309460b..fb5b5b2 100644 --- a/src/models/Network.ts +++ b/src/models/Network.ts @@ -1,76 +1,99 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ConfigReference } from '../models/ConfigReference.js'; import { IPAM } from '../models/IPAM.js'; import { PeerInfo } from '../models/PeerInfo.js'; -export class Network { +export interface Network { /** * Name of the network. */ - 'Name'?: string; + Name?: string; + /** * ID that uniquely identifies a network on a single machine. */ - 'Id'?: string; + Id?: string; + /** * Date and time at which the network was created in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'Created'?: string; + Created?: string; + /** - * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level) + * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level) */ - 'Scope'?: string; + Scope?: string; + /** - * The name of the driver used to create the network (e.g. `bridge`, `overlay`). + * The name of the driver used to create the network (e.g. `bridge`, `overlay`). */ - 'Driver'?: string; + Driver?: string; + /** * Whether the network was created with IPv4 enabled. */ - 'EnableIPv4'?: boolean; + EnableIPv4?: boolean; + /** * Whether the network was created with IPv6 enabled. */ - 'EnableIPv6'?: boolean; - 'IPAM'?: IPAM; + EnableIPv6?: boolean; + + IPAM?: IPAM; + /** * Whether the network is created to only allow internal networking connectivity. */ - 'Internal'?: boolean; + Internal?: boolean; + /** * Whether a global / swarm scope network is manually attachable by regular containers from workers in swarm mode. */ - 'Attachable'?: boolean; + Attachable?: boolean; + /** * Whether the network is providing the routing-mesh for the swarm cluster. */ - 'Ingress'?: boolean; - 'ConfigFrom'?: ConfigReference; + Ingress?: boolean; + + ConfigFrom?: ConfigReference; + /** * Whether the network is a config-only network. Config-only networks are placeholder networks for network configurations to be used by other networks. Config-only networks cannot be used directly to run containers or services. */ - 'ConfigOnly'?: boolean; + ConfigOnly?: boolean; + /** * Network-specific options uses when creating the network. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; + /** * Metadata specific to the network being created. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * List of peer nodes for an overlay network. This field is only present for overlay networks, and omitted for other network types. */ - 'Peers'?: Array; + Peers?: Array; } diff --git a/src/models/NetworkAttachmentConfig.ts b/src/models/NetworkAttachmentConfig.ts index 4d2c710..9f531ff 100644 --- a/src/models/NetworkAttachmentConfig.ts +++ b/src/models/NetworkAttachmentConfig.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Specifies how a service should be attached to a particular network. */ -export class NetworkAttachmentConfig { +export interface NetworkAttachmentConfig { /** * The target network for attachment. Must be a network name or ID. */ - 'Target'?: string; + Target?: string; + /** * Discoverable alternate names for the service on this network. */ - 'Aliases'?: Array; + Aliases?: Array; + /** * Driver attachment options for the network target. */ - 'DriverOpts'?: { [key: string]: string }; + DriverOpts?: { [key: string]: string }; } diff --git a/src/models/NetworkConnectRequest.ts b/src/models/NetworkConnectRequest.ts index 748d4d7..4fd4efa 100644 --- a/src/models/NetworkConnectRequest.ts +++ b/src/models/NetworkConnectRequest.ts @@ -1,21 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointSettings } from '../models/EndpointSettings.js'; -export class NetworkConnectRequest { +export interface NetworkConnectRequest { /** * The ID or name of the container to connect to the network. */ - 'Container'?: string; - 'EndpointConfig'?: EndpointSettings; + Container?: string; + + EndpointConfig?: EndpointSettings; } diff --git a/src/models/NetworkCreateRequest.ts b/src/models/NetworkCreateRequest.ts index 43748cf..8b2d7f3 100644 --- a/src/models/NetworkCreateRequest.ts +++ b/src/models/NetworkCreateRequest.ts @@ -1,63 +1,83 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ConfigReference } from '../models/ConfigReference.js'; import { IPAM } from '../models/IPAM.js'; -export class NetworkCreateRequest { +export interface NetworkCreateRequest { /** - * The network\'s name. + * The network\'s name. */ - 'Name': string; + Name: string; + /** * Name of the network driver plugin to use. */ - 'Driver'?: string; + Driver?: string; + /** - * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level). + * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level). */ - 'Scope'?: string; + Scope?: string; + /** * Restrict external access to the network. */ - 'Internal'?: boolean; + Internal?: boolean; + /** * Globally scoped network is manually attachable by regular containers from workers in swarm mode. */ - 'Attachable'?: boolean; + Attachable?: boolean; + /** * Ingress network is the network which provides the routing-mesh in swarm mode. */ - 'Ingress'?: boolean; + Ingress?: boolean; + /** * Creates a config-only network. Config-only networks are placeholder networks for network configurations to be used by other networks. Config-only networks cannot be used directly to run containers or services. */ - 'ConfigOnly'?: boolean; - 'ConfigFrom'?: ConfigReference; - 'IPAM'?: IPAM; + ConfigOnly?: boolean; + + ConfigFrom?: ConfigReference; + + IPAM?: IPAM; + /** * Enable IPv4 on the network. */ - 'EnableIPv4'?: boolean; + EnableIPv4?: boolean; + /** * Enable IPv6 on the network. */ - 'EnableIPv6'?: boolean; + EnableIPv6?: boolean; + /** * Network specific options to be used by the drivers. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; } diff --git a/src/models/NetworkCreateResponse.ts b/src/models/NetworkCreateResponse.ts index ab6a4e7..f888fa4 100644 --- a/src/models/NetworkCreateResponse.ts +++ b/src/models/NetworkCreateResponse.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * OK response to NetworkCreate operation */ -export class NetworkCreateResponse { +export interface NetworkCreateResponse { /** * The ID of the created network. */ - 'Id': string; + Id: string; + /** * Warnings encountered when creating the container */ - 'Warning': string; + Warning: string; } diff --git a/src/models/NetworkDisconnectRequest.ts b/src/models/NetworkDisconnectRequest.ts index 3e3fb40..0e3fd70 100644 --- a/src/models/NetworkDisconnectRequest.ts +++ b/src/models/NetworkDisconnectRequest.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class NetworkDisconnectRequest { +export interface NetworkDisconnectRequest { /** * The ID or name of the container to disconnect from the network. */ - 'Container'?: string; + Container?: string; + /** * Force the container to disconnect from the network. */ - 'Force'?: boolean; + Force?: boolean; } diff --git a/src/models/NetworkInspect.ts b/src/models/NetworkInspect.ts index d97f99e..4349760 100644 --- a/src/models/NetworkInspect.ts +++ b/src/models/NetworkInspect.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ConfigReference } from '../models/ConfigReference.js'; @@ -18,71 +26,88 @@ import { PeerInfo } from '../models/PeerInfo.js'; /** * The body of the \"get network\" http response message. */ -export class NetworkInspect { +export interface NetworkInspect { /** * Contains endpoints attached to the network. */ - 'Containers'?: { [key: string]: EndpointResource }; + Containers?: { [key: string]: EndpointResource }; + /** * List of services using the network. This field is only present for swarm scope networks, and omitted for local scope networks. */ - 'Services'?: { [key: string]: any }; + Services?: { [key: string]: any }; + /** * Name of the network. */ - 'Name'?: string; + Name?: string; + /** * ID that uniquely identifies a network on a single machine. */ - 'Id'?: string; + Id?: string; + /** * Date and time at which the network was created in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'Created'?: string; + Created?: string; + /** - * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level) + * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level) */ - 'Scope'?: string; + Scope?: string; + /** - * The name of the driver used to create the network (e.g. `bridge`, `overlay`). + * The name of the driver used to create the network (e.g. `bridge`, `overlay`). */ - 'Driver'?: string; + Driver?: string; + /** * Whether the network was created with IPv4 enabled. */ - 'EnableIPv4'?: boolean; + EnableIPv4?: boolean; + /** * Whether the network was created with IPv6 enabled. */ - 'EnableIPv6'?: boolean; - 'IPAM'?: IPAM; + EnableIPv6?: boolean; + + IPAM?: IPAM; + /** * Whether the network is created to only allow internal networking connectivity. */ - 'Internal'?: boolean; + Internal?: boolean; + /** * Whether a global / swarm scope network is manually attachable by regular containers from workers in swarm mode. */ - 'Attachable'?: boolean; + Attachable?: boolean; + /** * Whether the network is providing the routing-mesh for the swarm cluster. */ - 'Ingress'?: boolean; - 'ConfigFrom'?: ConfigReference; + Ingress?: boolean; + + ConfigFrom?: ConfigReference; + /** * Whether the network is a config-only network. Config-only networks are placeholder networks for network configurations to be used by other networks. Config-only networks cannot be used directly to run containers or services. */ - 'ConfigOnly'?: boolean; + ConfigOnly?: boolean; + /** * Network-specific options uses when creating the network. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; + /** * Metadata specific to the network being created. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * List of peer nodes for an overlay network. This field is only present for overlay networks, and omitted for other network types. */ - 'Peers'?: Array; + Peers?: Array; } diff --git a/src/models/NetworkPruneResponse.ts b/src/models/NetworkPruneResponse.ts index 78344e5..e05e9f3 100644 --- a/src/models/NetworkPruneResponse.ts +++ b/src/models/NetworkPruneResponse.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class NetworkPruneResponse { +export interface NetworkPruneResponse { /** * Networks that were deleted */ - 'NetworksDeleted'?: Array; + NetworksDeleted?: Array; } diff --git a/src/models/NetworkSettings.ts b/src/models/NetworkSettings.ts index 3957965..9f547de 100644 --- a/src/models/NetworkSettings.ts +++ b/src/models/NetworkSettings.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Address } from '../models/Address.js'; @@ -17,77 +25,94 @@ import { PortBinding } from '../models/PortBinding.js'; /** * NetworkSettings exposes the network settings in the API */ -export class NetworkSettings { +export interface NetworkSettings { /** - * Name of the default bridge interface when dockerd\'s --bridge flag is set. Deprecated: This field is only set when the daemon is started with the --bridge flag specified. + * Name of the default bridge interface when dockerd\'s --bridge flag is set. Deprecated: This field is only set when the daemon is started with the --bridge flag specified. */ - 'Bridge'?: string; + Bridge?: string; + /** - * SandboxID uniquely represents a container\'s network stack. + * SandboxID uniquely represents a container\'s network stack. */ - 'SandboxID'?: string; + SandboxID?: string; + /** * Indicates if hairpin NAT should be enabled on the virtual interface. Deprecated: This field is never set and will be removed in a future release. */ - 'HairpinMode'?: boolean; + HairpinMode?: boolean; + /** * IPv6 unicast address using the link-local prefix. Deprecated: This field is never set and will be removed in a future release. */ - 'LinkLocalIPv6Address'?: string; + LinkLocalIPv6Address?: string; + /** * Prefix length of the IPv6 unicast address. Deprecated: This field is never set and will be removed in a future release. */ - 'LinkLocalIPv6PrefixLen'?: number; + LinkLocalIPv6PrefixLen?: number; + /** - * PortMap describes the mapping of container ports to host ports, using the container\'s port-number and protocol as key in the format `/`, for example, `80/udp`. If a container\'s port is mapped for multiple protocols, separate entries are added to the mapping table. + * PortMap describes the mapping of container ports to host ports, using the container\'s port-number and protocol as key in the format `<port>/<protocol>`, for example, `80/udp`. If a container\'s port is mapped for multiple protocols, separate entries are added to the mapping table. */ - 'Ports'?: { [key: string]: Array | null }; + Ports?: { [key: string]: Array | null }; + /** * SandboxKey is the full path of the netns handle */ - 'SandboxKey'?: string; + SandboxKey?: string; + /** * Deprecated: This field is never set and will be removed in a future release. */ - 'SecondaryIPAddresses'?: Array
| null; + SecondaryIPAddresses?: Array
| null; + /** * Deprecated: This field is never set and will be removed in a future release. */ - 'SecondaryIPv6Addresses'?: Array
| null; + SecondaryIPv6Addresses?: Array
| null; + /** - * EndpointID uniquely represents a service endpoint in a Sandbox.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * EndpointID uniquely represents a service endpoint in a Sandbox. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'EndpointID'?: string; + EndpointID?: string; + /** - * Gateway address for the default \"bridge\" network.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * Gateway address for the default \"bridge\" network. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'Gateway'?: string; + Gateway?: string; + /** - * Global IPv6 address for the default \"bridge\" network.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * Global IPv6 address for the default \"bridge\" network. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'GlobalIPv6Address'?: string; + GlobalIPv6Address?: string; + /** - * Mask length of the global IPv6 address.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * Mask length of the global IPv6 address. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'GlobalIPv6PrefixLen'?: number; + GlobalIPv6PrefixLen?: number; + /** - * IPv4 address for the default \"bridge\" network.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * IPv4 address for the default \"bridge\" network. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'IPAddress'?: string; + IPAddress?: string; + /** - * Mask length of the IPv4 address.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * Mask length of the IPv4 address. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'IPPrefixLen'?: number; + IPPrefixLen?: number; + /** - * IPv6 gateway address for this network.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * IPv6 gateway address for this network. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'IPv6Gateway'?: string; + IPv6Gateway?: string; + /** - * MAC address for the container on the default \"bridge\" network.


> **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 + * MAC address for the container on the default \"bridge\" network. <p><br /></p> > **Deprecated**: This field is only propagated when attached to the > default \"bridge\" network. Use the information from the \"bridge\" > network inside the `Networks` map instead, which contains the same > information. This field was deprecated in Docker 1.9 and is scheduled > to be removed in Docker 17.12.0 */ - 'MacAddress'?: string; + MacAddress?: string; + /** * Information about all networks that the container is connected to. */ - 'Networks'?: { [key: string]: EndpointSettings }; + Networks?: { [key: string]: EndpointSettings }; } diff --git a/src/models/NetworkSummary.ts b/src/models/NetworkSummary.ts index 47d9c61..be04c2c 100644 --- a/src/models/NetworkSummary.ts +++ b/src/models/NetworkSummary.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ConfigReference } from '../models/ConfigReference.js'; @@ -17,63 +25,78 @@ import { PeerInfo } from '../models/PeerInfo.js'; /** * Network list response item */ -export class NetworkSummary { +export interface NetworkSummary { /** * Name of the network. */ - 'Name'?: string; + Name?: string; + /** * ID that uniquely identifies a network on a single machine. */ - 'Id'?: string; + Id?: string; + /** * Date and time at which the network was created in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'Created'?: string; + Created?: string; + /** - * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level) + * The level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level) */ - 'Scope'?: string; + Scope?: string; + /** - * The name of the driver used to create the network (e.g. `bridge`, `overlay`). + * The name of the driver used to create the network (e.g. `bridge`, `overlay`). */ - 'Driver'?: string; + Driver?: string; + /** * Whether the network was created with IPv4 enabled. */ - 'EnableIPv4'?: boolean; + EnableIPv4?: boolean; + /** * Whether the network was created with IPv6 enabled. */ - 'EnableIPv6'?: boolean; - 'IPAM'?: IPAM; + EnableIPv6?: boolean; + + IPAM?: IPAM; + /** * Whether the network is created to only allow internal networking connectivity. */ - 'Internal'?: boolean; + Internal?: boolean; + /** * Whether a global / swarm scope network is manually attachable by regular containers from workers in swarm mode. */ - 'Attachable'?: boolean; + Attachable?: boolean; + /** * Whether the network is providing the routing-mesh for the swarm cluster. */ - 'Ingress'?: boolean; - 'ConfigFrom'?: ConfigReference; + Ingress?: boolean; + + ConfigFrom?: ConfigReference; + /** * Whether the network is a config-only network. Config-only networks are placeholder networks for network configurations to be used by other networks. Config-only networks cannot be used directly to run containers or services. */ - 'ConfigOnly'?: boolean; + ConfigOnly?: boolean; + /** * Network-specific options uses when creating the network. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; + /** * Metadata specific to the network being created. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * List of peer nodes for an overlay network. This field is only present for overlay networks, and omitted for other network types. */ - 'Peers'?: Array; + Peers?: Array; } diff --git a/src/models/NetworkTaskInfo.ts b/src/models/NetworkTaskInfo.ts index 16e3e51..c2af250 100644 --- a/src/models/NetworkTaskInfo.ts +++ b/src/models/NetworkTaskInfo.ts @@ -1,21 +1,32 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * carries the information about one backend task */ -export class NetworkTaskInfo { - 'Name'?: string; - 'EndpointID'?: string; - 'EndpointIP'?: string; - 'Info'?: { [key: string]: string }; +export interface NetworkTaskInfo { + Name?: string; + + EndpointID?: string; + + EndpointIP?: string; + + Info?: { [key: string]: string }; } diff --git a/src/models/NetworkingConfig.ts b/src/models/NetworkingConfig.ts index 8f4cd4e..06d8b7d 100644 --- a/src/models/NetworkingConfig.ts +++ b/src/models/NetworkingConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointSettings } from '../models/EndpointSettings.js'; @@ -15,9 +23,9 @@ import { EndpointSettings } from '../models/EndpointSettings.js'; /** * NetworkingConfig represents the container\'s networking configuration for each of its interfaces. It is used for the networking configs specified in the `docker create` and `docker network connect` commands. */ -export class NetworkingConfig { +export interface NetworkingConfig { /** * A mapping of network name to endpoint configuration for that network. The endpoint configuration can be left empty to connect to that network with no particular endpoint configuration. */ - 'EndpointsConfig'?: { [key: string]: EndpointSettings }; + EndpointsConfig?: { [key: string]: EndpointSettings }; } diff --git a/src/models/Node.ts b/src/models/Node.ts index 1f1e800..8ef3bbb 100644 --- a/src/models/Node.ts +++ b/src/models/Node.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ManagerStatus } from '../models/ManagerStatus.js'; @@ -16,19 +24,26 @@ import { NodeSpec } from '../models/NodeSpec.js'; import { NodeStatus } from '../models/NodeStatus.js'; import { ObjectVersion } from '../models/ObjectVersion.js'; -export class Node { - 'ID'?: string; - 'Version'?: ObjectVersion; +export interface Node { + ID?: string; + + Version?: ObjectVersion; + /** * Date and time at which the node was added to the swarm in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'CreatedAt'?: string; + CreatedAt?: string; + /** * Date and time at which the node was last updated in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'UpdatedAt'?: string; - 'Spec'?: NodeSpec; - 'Description'?: NodeDescription; - 'Status'?: NodeStatus; - 'ManagerStatus'?: ManagerStatus | null; + UpdatedAt?: string; + + Spec?: NodeSpec; + + Description?: NodeDescription; + + Status?: NodeStatus; + + ManagerStatus?: ManagerStatus | null; } diff --git a/src/models/NodeDescription.ts b/src/models/NodeDescription.ts index 97339d6..30e309c 100644 --- a/src/models/NodeDescription.ts +++ b/src/models/NodeDescription.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EngineDescription } from '../models/EngineDescription.js'; @@ -18,10 +26,14 @@ import { TLSInfo } from '../models/TLSInfo.js'; /** * NodeDescription encapsulates the properties of the Node as reported by the agent. */ -export class NodeDescription { - 'Hostname'?: string; - 'Platform'?: Platform; - 'Resources'?: ResourceObject; - 'Engine'?: EngineDescription; - 'TLSInfo'?: TLSInfo; +export interface NodeDescription { + Hostname?: string; + + Platform?: Platform; + + Resources?: ResourceObject; + + Engine?: EngineDescription; + + TLSInfo?: TLSInfo; } diff --git a/src/models/NodeSpec.ts b/src/models/NodeSpec.ts index 5d2e293..1d5d9f6 100644 --- a/src/models/NodeSpec.ts +++ b/src/models/NodeSpec.ts @@ -1,40 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class NodeSpec { +export interface NodeSpec { /** * Name for the node. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Role of the node. */ - 'Role'?: NodeSpecRoleEnum; + Role?: NodeSpecRoleEnum; + /** * Availability of the node. */ - 'Availability'?: NodeSpecAvailabilityEnum; + Availability?: NodeSpecAvailabilityEnum; } -export enum NodeSpecRoleEnum { - Worker = 'worker', - Manager = 'manager', -} -export enum NodeSpecAvailabilityEnum { - Active = 'active', - Pause = 'pause', - Drain = 'drain', -} +export type NodeSpecRoleEnum = 'worker' | 'manager'; +export type NodeSpecAvailabilityEnum = 'active' | 'pause' | 'drain'; diff --git a/src/models/NodeState.ts b/src/models/NodeState.ts index bd25b11..cec2c15 100644 --- a/src/models/NodeState.ts +++ b/src/models/NodeState.ts @@ -1,21 +1,24 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * NodeState represents the state of a node. */ -export enum NodeState { - Unknown = 'unknown', - Down = 'down', - Ready = 'ready', - Disconnected = 'disconnected', -} +export type NodeState = 'unknown' | 'down' | 'ready' | 'disconnected'; diff --git a/src/models/NodeStatus.ts b/src/models/NodeStatus.ts index dc882ea..220a90d 100644 --- a/src/models/NodeStatus.ts +++ b/src/models/NodeStatus.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { NodeState } from '../models/NodeState.js'; @@ -15,11 +23,13 @@ import { NodeState } from '../models/NodeState.js'; /** * NodeStatus represents the status of a node. It provides the current status of the node, as seen by the manager. */ -export class NodeStatus { - 'State'?: NodeState; - 'Message'?: string; +export interface NodeStatus { + State?: NodeState; + + Message?: string; + /** * IP address of the node. */ - 'Addr'?: string; + Addr?: string; } diff --git a/src/models/OCIDescriptor.ts b/src/models/OCIDescriptor.ts index 9807368..f41af12 100644 --- a/src/models/OCIDescriptor.ts +++ b/src/models/OCIDescriptor.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { OCIPlatform } from '../models/OCIPlatform.js'; @@ -15,34 +23,41 @@ import { OCIPlatform } from '../models/OCIPlatform.js'; /** * A descriptor struct containing digest, media type, and size, as defined in the [OCI Content Descriptors Specification](https://github.com/opencontainers/image-spec/blob/v1.0.1/descriptor.md). */ -export class OCIDescriptor { +export interface OCIDescriptor { /** * The media type of the object this schema refers to. */ - 'MediaType'?: string; + MediaType?: string; + /** * The digest of the targeted content. */ - 'Digest'?: string; + Digest?: string; + /** * The size in bytes of the blob. */ - 'Size'?: number; + Size?: number; + /** * List of URLs from which this object MAY be downloaded. */ - 'Urls'?: Array | null; + Urls?: Array | null; + /** * Arbitrary metadata relating to the targeted content. */ - 'Annotations'?: { [key: string]: string } | null; + Annotations?: { [key: string]: string } | null; + /** * Data is an embedding of the targeted content. This is encoded as a base64 string when marshalled to JSON (automatically, by encoding/json). If present, Data can be used directly to avoid fetching the targeted content. */ - 'Data'?: string | null; - 'Platform'?: OCIPlatform | null; + Data?: string | null; + + Platform?: OCIPlatform | null; + /** * ArtifactType is the IANA media type of this artifact. */ - 'ArtifactType'?: string | null; + ArtifactType?: string | null; } diff --git a/src/models/OCIPlatform.ts b/src/models/OCIPlatform.ts index d5f5501..5be259d 100644 --- a/src/models/OCIPlatform.ts +++ b/src/models/OCIPlatform.ts @@ -1,37 +1,49 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Describes the platform which the image in the manifest runs on, as defined in the [OCI Image Index Specification](https://github.com/opencontainers/image-spec/blob/v1.0.1/image-index.md). */ -export class OCIPlatform { +export interface OCIPlatform { /** - * The CPU architecture, for example `amd64` or `ppc64`. + * The CPU architecture, for example `amd64` or `ppc64`. */ - 'Architecture'?: string; + Architecture?: string; + /** - * The operating system, for example `linux` or `windows`. + * The operating system, for example `linux` or `windows`. */ - 'Os'?: string; + Os?: string; + /** - * Optional field specifying the operating system version, for example on Windows `10.0.19041.1165`. + * Optional field specifying the operating system version, for example on Windows `10.0.19041.1165`. */ - 'OsVersion'?: string; + OsVersion?: string; + /** - * Optional field specifying an array of strings, each listing a required OS feature (for example on Windows `win32k`). + * Optional field specifying an array of strings, each listing a required OS feature (for example on Windows `win32k`). */ - 'OsFeatures'?: Array; + OsFeatures?: Array; + /** - * Optional field specifying a variant of the CPU, for example `v7` to specify ARMv7 when architecture is `arm`. + * Optional field specifying a variant of the CPU, for example `v7` to specify ARMv7 when architecture is `arm`. */ - 'Variant'?: string; + Variant?: string; } diff --git a/src/models/ObjectVersion.ts b/src/models/ObjectVersion.ts index 5e220c2..f9084ab 100644 --- a/src/models/ObjectVersion.ts +++ b/src/models/ObjectVersion.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The version number of the object such as node, service, etc. This is needed to avoid conflicting writes. The client must send the version number along with the modified specification when updating these objects. This approach ensures safe concurrency and determinism in that the change on the object may not be applied if the version number has changed from the last read. In other words, if two update requests specify the same base version, only one of the requests can succeed. As a result, two separate update requests that happen at the same time will not unintentionally overwrite each other. */ -export class ObjectVersion { - 'Index'?: number; +export interface ObjectVersion { + Index?: number; } diff --git a/src/models/PeerInfo.ts b/src/models/PeerInfo.ts index 2d4b9a1..8f7422b 100644 --- a/src/models/PeerInfo.ts +++ b/src/models/PeerInfo.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * represents one peer of an overlay network. */ -export class PeerInfo { +export interface PeerInfo { /** * ID of the peer-node in the Swarm cluster. */ - 'Name'?: string; + Name?: string; + /** * IP-address of the peer-node in the Swarm cluster. */ - 'IP'?: string; + IP?: string; } diff --git a/src/models/PeerNode.ts b/src/models/PeerNode.ts index 52c012d..92fd791 100644 --- a/src/models/PeerNode.ts +++ b/src/models/PeerNode.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Represents a peer-node in the swarm */ -export class PeerNode { +export interface PeerNode { /** * Unique identifier of for this node in the swarm. */ - 'NodeID'?: string; + NodeID?: string; + /** * IP address and ports at which this node can be reached. */ - 'Addr'?: string; + Addr?: string; } diff --git a/src/models/Platform.ts b/src/models/Platform.ts index 15d2446..e5d457a 100644 --- a/src/models/Platform.ts +++ b/src/models/Platform.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Platform represents the platform (Arch/OS). */ -export class Platform { +export interface Platform { /** - * Architecture represents the hardware architecture (for example, `x86_64`). + * Architecture represents the hardware architecture (for example, `x86_64`). */ - 'Architecture'?: string; + Architecture?: string; + /** - * OS represents the Operating System (for example, `linux` or `windows`). + * OS represents the Operating System (for example, `linux` or `windows`). */ - 'OS'?: string; + OS?: string; } diff --git a/src/models/Plugin.ts b/src/models/Plugin.ts index 9760d48..dbd8229 100644 --- a/src/models/Plugin.ts +++ b/src/models/Plugin.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { PluginConfig } from '../models/PluginConfig.js'; @@ -16,17 +24,22 @@ import { PluginSettings } from '../models/PluginSettings.js'; /** * A plugin for the Engine API */ -export class Plugin { - 'Id'?: string; - 'Name': string; +export interface Plugin { + Id?: string; + + Name: string; + /** * True if the plugin is running. False if the plugin is not running, only installed. */ - 'Enabled': boolean; - 'Settings': PluginSettings; + Enabled: boolean; + + Settings: PluginSettings; + /** * plugin remote reference used to push/pull the plugin */ - 'PluginReference'?: string; - 'Config': PluginConfig; + PluginReference?: string; + + Config: PluginConfig; } diff --git a/src/models/PluginConfig.ts b/src/models/PluginConfig.ts index 4252eab..8d5b4cd 100644 --- a/src/models/PluginConfig.ts +++ b/src/models/PluginConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { PluginConfigArgs } from '../models/PluginConfigArgs.js'; @@ -22,24 +30,39 @@ import { PluginMount } from '../models/PluginMount.js'; /** * The config of a plugin. */ -export class PluginConfig { +export interface PluginConfig { /** * Docker Version used to create the plugin */ - 'DockerVersion'?: string; - 'Description': string; - 'Documentation': string; - '_interface': PluginConfigInterface; - 'Entrypoint': Array; - 'WorkDir': string; - 'User'?: PluginConfigUser; - 'Network': PluginConfigNetwork; - 'Linux': PluginConfigLinux; - 'PropagatedMount': string; - 'IpcHost': boolean; - 'PidHost': boolean; - 'Mounts': Array; - 'Env': Array; - 'Args': PluginConfigArgs; - 'Rootfs'?: PluginConfigRootfs; + DockerVersion?: string; + + Description: string; + + Documentation: string; + + _interface: PluginConfigInterface; + + Entrypoint: Array; + + WorkDir: string; + + User?: PluginConfigUser; + + Network: PluginConfigNetwork; + + Linux: PluginConfigLinux; + + PropagatedMount: string; + + IpcHost: boolean; + + PidHost: boolean; + + Mounts: Array; + + Env: Array; + + Args: PluginConfigArgs; + + Rootfs?: PluginConfigRootfs; } diff --git a/src/models/PluginConfigArgs.ts b/src/models/PluginConfigArgs.ts index 4de834d..ab458a2 100644 --- a/src/models/PluginConfigArgs.ts +++ b/src/models/PluginConfigArgs.ts @@ -1,18 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginConfigArgs { - 'Name': string; - 'Description': string; - 'Settable': Array; - 'Value': Array; +export interface PluginConfigArgs { + Name: string; + + Description: string; + + Settable: Array; + + Value: Array; } diff --git a/src/models/PluginConfigInterface.ts b/src/models/PluginConfigInterface.ts index 3332ee5..72dce42 100644 --- a/src/models/PluginConfigInterface.ts +++ b/src/models/PluginConfigInterface.ts @@ -1,28 +1,37 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The interface between Docker and the plugin */ -export class PluginConfigInterface { - 'Types': Array; - 'Socket': string; +export interface PluginConfigInterface { + Types: Array; + + Socket: string; + /** * Protocol to use for clients connecting to the plugin. */ - 'ProtocolScheme'?: PluginConfigInterfaceProtocolSchemeEnum; + ProtocolScheme?: PluginConfigInterfaceProtocolSchemeEnum; } -export enum PluginConfigInterfaceProtocolSchemeEnum { - Empty = '', - MobyPluginsHttpV1 = 'moby.plugins.http/v1', -} +export type PluginConfigInterfaceProtocolSchemeEnum = + | '' + | 'moby.plugins.http/v1'; diff --git a/src/models/PluginConfigLinux.ts b/src/models/PluginConfigLinux.ts index b1abc75..0b52115 100644 --- a/src/models/PluginConfigLinux.ts +++ b/src/models/PluginConfigLinux.ts @@ -1,19 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { PluginDevice } from '../models/PluginDevice.js'; -export class PluginConfigLinux { - 'Capabilities': Array; - 'AllowAllDevices': boolean; - 'Devices': Array; +export interface PluginConfigLinux { + Capabilities: Array; + + AllowAllDevices: boolean; + + Devices: Array; } diff --git a/src/models/PluginConfigNetwork.ts b/src/models/PluginConfigNetwork.ts index 0f4b117..8136376 100644 --- a/src/models/PluginConfigNetwork.ts +++ b/src/models/PluginConfigNetwork.ts @@ -1,15 +1,23 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginConfigNetwork { - 'Type': string; +export interface PluginConfigNetwork { + Type: string; } diff --git a/src/models/PluginConfigRootfs.ts b/src/models/PluginConfigRootfs.ts index 97eb3ec..e6bfb6a 100644 --- a/src/models/PluginConfigRootfs.ts +++ b/src/models/PluginConfigRootfs.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginConfigRootfs { - 'Type'?: string; - 'DiffIds'?: Array; +export interface PluginConfigRootfs { + Type?: string; + + DiffIds?: Array; } diff --git a/src/models/PluginConfigUser.ts b/src/models/PluginConfigUser.ts index 3420373..9c1e8e5 100644 --- a/src/models/PluginConfigUser.ts +++ b/src/models/PluginConfigUser.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginConfigUser { - 'UID'?: number; - 'GID'?: number; +export interface PluginConfigUser { + UID?: number; + + GID?: number; } diff --git a/src/models/PluginDevice.ts b/src/models/PluginDevice.ts index 2cd7d14..571dbe3 100644 --- a/src/models/PluginDevice.ts +++ b/src/models/PluginDevice.ts @@ -1,18 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginDevice { - 'Name': string; - 'Description': string; - 'Settable': Array; - 'Path': string; +export interface PluginDevice { + Name: string; + + Description: string; + + Settable: Array; + + Path: string; } diff --git a/src/models/PluginEnv.ts b/src/models/PluginEnv.ts index c30ac64..3467948 100644 --- a/src/models/PluginEnv.ts +++ b/src/models/PluginEnv.ts @@ -1,18 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginEnv { - 'Name': string; - 'Description': string; - 'Settable': Array; - 'Value': string; +export interface PluginEnv { + Name: string; + + Description: string; + + Settable: Array; + + Value: string; } diff --git a/src/models/PluginMount.ts b/src/models/PluginMount.ts index bf44fdf..7f2a83c 100644 --- a/src/models/PluginMount.ts +++ b/src/models/PluginMount.ts @@ -1,21 +1,35 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class PluginMount { - 'Name': string; - 'Description': string; - 'Settable': Array; - 'Source': string; - 'Destination': string; - 'Type': string; - 'Options': Array; +export interface PluginMount { + Name: string; + + Description: string; + + Settable: Array; + + Source: string; + + Destination: string; + + Type: string; + + Options: Array; } diff --git a/src/models/PluginPrivilege.ts b/src/models/PluginPrivilege.ts index 39bde1c..a1ce1fd 100644 --- a/src/models/PluginPrivilege.ts +++ b/src/models/PluginPrivilege.ts @@ -1,20 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Describes a permission the user has to accept upon installing the plugin. */ -export class PluginPrivilege { - 'Name'?: string; - 'Description'?: string; - 'Value'?: Array; +export interface PluginPrivilege { + Name?: string; + + Description?: string; + + Value?: Array; } diff --git a/src/models/PluginSettings.ts b/src/models/PluginSettings.ts index 23290cf..57dd95c 100644 --- a/src/models/PluginSettings.ts +++ b/src/models/PluginSettings.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { PluginDevice } from '../models/PluginDevice.js'; @@ -16,9 +24,12 @@ import { PluginMount } from '../models/PluginMount.js'; /** * user-configurable settings for the plugin. */ -export class PluginSettings { - 'Mounts': Array; - 'Env': Array; - 'Args': Array; - 'Devices': Array; +export interface PluginSettings { + Mounts: Array; + + Env: Array; + + Args: Array; + + Devices: Array; } diff --git a/src/models/PluginsInfo.ts b/src/models/PluginsInfo.ts index 2363464..5629c8e 100644 --- a/src/models/PluginsInfo.ts +++ b/src/models/PluginsInfo.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Available plugins per type.


> **Note**: Only unmanaged (V1) plugins are included in this list. > V1 plugins are \"lazily\" loaded, and are not returned in this list > if there is no resource using the plugin. */ -export class PluginsInfo { +export interface PluginsInfo { /** * Names of available volume-drivers, and network-driver plugins. */ - 'Volume'?: Array; + Volume?: Array; + /** * Names of available network-drivers, and network-driver plugins. */ - 'Network'?: Array; + Network?: Array; + /** * Names of available authorization plugins. */ - 'Authorization'?: Array; + Authorization?: Array; + /** * Names of available logging-drivers, and logging-driver plugins. */ - 'Log'?: Array; + Log?: Array; } diff --git a/src/models/PortBinding.ts b/src/models/PortBinding.ts index 5ff5a23..1b1aa45 100644 --- a/src/models/PortBinding.ts +++ b/src/models/PortBinding.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * PortBinding represents a binding between a host IP address and a host port. */ -export class PortBinding { +export interface PortBinding { /** - * Host IP address that the container\'s port is mapped to. + * Host IP address that the container\'s port is mapped to. */ - 'HostIp'?: string; + HostIp?: string; + /** - * Host port number that the container\'s port is mapped to. + * Host port number that the container\'s port is mapped to. */ - 'HostPort'?: string; + HostPort?: string; } diff --git a/src/models/PortStatus.ts b/src/models/PortStatus.ts index 328a9e9..1211207 100644 --- a/src/models/PortStatus.ts +++ b/src/models/PortStatus.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointPortConfig } from '../models/EndpointPortConfig.js'; @@ -15,6 +23,6 @@ import { EndpointPortConfig } from '../models/EndpointPortConfig.js'; /** * represents the port status of a task\'s host ports whose service has published host ports */ -export class PortStatus { - 'Ports'?: Array; +export interface PortStatus { + Ports?: Array; } diff --git a/src/models/PortSummary.ts b/src/models/PortSummary.ts index 2cce223..3cfb869 100644 --- a/src/models/PortSummary.ts +++ b/src/models/PortSummary.ts @@ -1,36 +1,43 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Describes a port-mapping between the container and the host. */ -export class PortSummary { +export interface PortSummary { /** - * Host IP address that the container\'s port is mapped to + * Host IP address that the container\'s port is mapped to */ - 'IP'?: string; + IP?: string; + /** * Port on the container */ - 'PrivatePort': number; + PrivatePort: number; + /** * Port exposed on the host */ - 'PublicPort'?: number; - 'Type': PortSummaryTypeEnum; -} + PublicPort?: number; -export enum PortSummaryTypeEnum { - Tcp = 'tcp', - Udp = 'udp', - Sctp = 'sctp', + Type: PortSummaryTypeEnum; } + +export type PortSummaryTypeEnum = 'tcp' | 'udp' | 'sctp'; diff --git a/src/models/ProcessConfig.ts b/src/models/ProcessConfig.ts index 01348ea..4d09b4a 100644 --- a/src/models/ProcessConfig.ts +++ b/src/models/ProcessConfig.ts @@ -1,19 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ProcessConfig { - 'Privileged'?: boolean; - 'User'?: string; - 'Tty'?: boolean; - 'Entrypoint'?: string; - 'Arguments'?: Array; +export interface ProcessConfig { + Privileged?: boolean; + + User?: string; + + Tty?: boolean; + + Entrypoint?: string; + + Arguments?: Array; } diff --git a/src/models/ProgressDetail.ts b/src/models/ProgressDetail.ts index 37c7a0e..4c5a3e5 100644 --- a/src/models/ProgressDetail.ts +++ b/src/models/ProgressDetail.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ProgressDetail { - 'Current'?: number; - 'Total'?: number; +export interface ProgressDetail { + Current?: number; + + Total?: number; } diff --git a/src/models/PushImageInfo.ts b/src/models/PushImageInfo.ts index 14f4fb8..331d1c1 100644 --- a/src/models/PushImageInfo.ts +++ b/src/models/PushImageInfo.ts @@ -1,20 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ErrorDetail } from '../models/ErrorDetail.js'; import { ProgressDetail } from '../models/ProgressDetail.js'; -export class PushImageInfo { - 'ErrorDetail'?: ErrorDetail; - 'Status'?: string; - 'ProgressDetail'?: ProgressDetail; +export interface PushImageInfo { + ErrorDetail?: ErrorDetail; + + Status?: string; + + ProgressDetail?: ProgressDetail; } diff --git a/src/models/Reachability.ts b/src/models/Reachability.ts index 2239307..6dd28a1 100644 --- a/src/models/Reachability.ts +++ b/src/models/Reachability.ts @@ -1,20 +1,24 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Reachability represents the reachability of a node. */ -export enum Reachability { - Unknown = 'unknown', - Unreachable = 'unreachable', - Reachable = 'reachable', -} +export type Reachability = 'unknown' | 'unreachable' | 'reachable'; diff --git a/src/models/RegistryServiceConfig.ts b/src/models/RegistryServiceConfig.ts index 6720306..27bc4a0 100644 --- a/src/models/RegistryServiceConfig.ts +++ b/src/models/RegistryServiceConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { IndexInfo } from '../models/IndexInfo.js'; @@ -15,14 +23,16 @@ import { IndexInfo } from '../models/IndexInfo.js'; /** * RegistryServiceConfig stores daemon registry services configuration. */ -export class RegistryServiceConfig { +export interface RegistryServiceConfig { /** - * List of IP ranges of insecure registries, using the CIDR syntax ([RFC 4632](https://tools.ietf.org/html/4632)). Insecure registries accept un-encrypted (HTTP) and/or untrusted (HTTPS with certificates from unknown CAs) communication. By default, local registries (`::1/128` and `127.0.0.0/8`) are configured as insecure. All other registries are secure. Communicating with an insecure registry is not possible if the daemon assumes that registry is secure. This configuration override this behavior, insecure communication with registries whose resolved IP address is within the subnet described by the CIDR syntax. Registries can also be marked insecure by hostname. Those registries are listed under `IndexConfigs` and have their `Secure` field set to `false`. > **Warning**: Using this option can be useful when running a local > registry, but introduces security vulnerabilities. This option > should therefore ONLY be used for testing purposes. For increased > security, users should add their CA to their system\'s list of trusted > CAs instead of enabling this option. + * List of IP ranges of insecure registries, using the CIDR syntax ([RFC 4632](https://tools.ietf.org/html/4632)). Insecure registries accept un-encrypted (HTTP) and/or untrusted (HTTPS with certificates from unknown CAs) communication. By default, local registries (`::1/128` and `127.0.0.0/8`) are configured as insecure. All other registries are secure. Communicating with an insecure registry is not possible if the daemon assumes that registry is secure. This configuration override this behavior, insecure communication with registries whose resolved IP address is within the subnet described by the CIDR syntax. Registries can also be marked insecure by hostname. Those registries are listed under `IndexConfigs` and have their `Secure` field set to `false`. > **Warning**: Using this option can be useful when running a local > registry, but introduces security vulnerabilities. This option > should therefore ONLY be used for testing purposes. For increased > security, users should add their CA to their system\'s list of trusted > CAs instead of enabling this option. */ - 'InsecureRegistryCIDRs'?: Array; - 'IndexConfigs'?: { [key: string]: IndexInfo }; + InsecureRegistryCIDRs?: Array; + + IndexConfigs?: { [key: string]: IndexInfo }; + /** - * List of registry URLs that act as a mirror for the official (`docker.io`) registry. + * List of registry URLs that act as a mirror for the official (`docker.io`) registry. */ - 'Mirrors'?: Array; + Mirrors?: Array; } diff --git a/src/models/ResourceObject.ts b/src/models/ResourceObject.ts index c6aa30f..f8dbc98 100644 --- a/src/models/ResourceObject.ts +++ b/src/models/ResourceObject.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { GenericResourcesInner } from '../models/GenericResourcesInner.js'; @@ -15,11 +23,13 @@ import { GenericResourcesInner } from '../models/GenericResourcesInner.js'; /** * An object describing the resources which can be advertised by a node and requested by a task. */ -export class ResourceObject { - 'NanoCPUs'?: number; - 'MemoryBytes'?: number; +export interface ResourceObject { + NanoCPUs?: number; + + MemoryBytes?: number; + /** - * User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, `GPU=UUID1`). + * User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, `GPU=UUID1`). */ - 'GenericResources'?: Array; + GenericResources?: Array; } diff --git a/src/models/Resources.ts b/src/models/Resources.ts index 7aa511a..275cf5a 100644 --- a/src/models/Resources.ts +++ b/src/models/Resources.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { DeviceMapping } from '../models/DeviceMapping.js'; @@ -19,129 +27,159 @@ import { ThrottleDevice } from '../models/ThrottleDevice.js'; /** * A container\'s resources (cgroups config, ulimits, etc) */ -export class Resources { +export interface Resources { /** - * An integer value representing this container\'s relative CPU weight versus other containers. + * An integer value representing this container\'s relative CPU weight versus other containers. */ - 'CpuShares'?: number; + CpuShares?: number; + /** * Memory limit in bytes. */ - 'Memory'?: number; + Memory?: number; + /** - * Path to `cgroups` under which the container\'s `cgroup` is created. If the path is not absolute, the path is considered to be relative to the `cgroups` path of the init process. Cgroups are created if they do not already exist. + * Path to `cgroups` under which the container\'s `cgroup` is created. If the path is not absolute, the path is considered to be relative to the `cgroups` path of the init process. Cgroups are created if they do not already exist. */ - 'CgroupParent'?: string; + CgroupParent?: string; + /** * Block IO weight (relative weight). */ - 'BlkioWeight'?: number; + BlkioWeight?: number; + /** - * Block IO weight (relative device weight) in the form: ``` [{\"Path\": \"device_path\", \"Weight\": weight}] ``` + * Block IO weight (relative device weight) in the form: ``` [{\"Path\": \"device_path\", \"Weight\": weight}] ``` */ - 'BlkioWeightDevice'?: Array; + BlkioWeightDevice?: Array; + /** - * Limit read rate (bytes per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit read rate (bytes per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceReadBps'?: Array; + BlkioDeviceReadBps?: Array; + /** - * Limit write rate (bytes per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit write rate (bytes per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceWriteBps'?: Array; + BlkioDeviceWriteBps?: Array; + /** - * Limit read rate (IO per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit read rate (IO per second) from a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceReadIOps'?: Array; + BlkioDeviceReadIOps?: Array; + /** - * Limit write rate (IO per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` + * Limit write rate (IO per second) to a device, in the form: ``` [{\"Path\": \"device_path\", \"Rate\": rate}] ``` */ - 'BlkioDeviceWriteIOps'?: Array; + BlkioDeviceWriteIOps?: Array; + /** * The length of a CPU period in microseconds. */ - 'CpuPeriod'?: number; + CpuPeriod?: number; + /** * Microseconds of CPU time that the container can get in a CPU period. */ - 'CpuQuota'?: number; + CpuQuota?: number; + /** * The length of a CPU real-time period in microseconds. Set to 0 to allocate no time allocated to real-time tasks. */ - 'CpuRealtimePeriod'?: number; + CpuRealtimePeriod?: number; + /** * The length of a CPU real-time runtime in microseconds. Set to 0 to allocate no time allocated to real-time tasks. */ - 'CpuRealtimeRuntime'?: number; + CpuRealtimeRuntime?: number; + /** - * CPUs in which to allow execution (e.g., `0-3`, `0,1`). + * CPUs in which to allow execution (e.g., `0-3`, `0,1`). */ - 'CpusetCpus'?: string; + CpusetCpus?: string; + /** * Memory nodes (MEMs) in which to allow execution (0-3, 0,1). Only effective on NUMA systems. */ - 'CpusetMems'?: string; + CpusetMems?: string; + /** * A list of devices to add to the container. */ - 'Devices'?: Array; + Devices?: Array; + /** * a list of cgroup rules to apply to the container */ - 'DeviceCgroupRules'?: Array; + DeviceCgroupRules?: Array; + /** * A list of requests for devices to be sent to device drivers. */ - 'DeviceRequests'?: Array; + DeviceRequests?: Array; + /** * Hard limit for kernel TCP buffer memory (in bytes). Depending on the OCI runtime in use, this option may be ignored. It is no longer supported by the default (runc) runtime. This field is omitted when empty. */ - 'KernelMemoryTCP'?: number; + KernelMemoryTCP?: number; + /** * Memory soft limit in bytes. */ - 'MemoryReservation'?: number; + MemoryReservation?: number; + /** - * Total memory limit (memory + swap). Set as `-1` to enable unlimited swap. + * Total memory limit (memory + swap). Set as `-1` to enable unlimited swap. */ - 'MemorySwap'?: number; + MemorySwap?: number; + /** - * Tune a container\'s memory swappiness behavior. Accepts an integer between 0 and 100. + * Tune a container\'s memory swappiness behavior. Accepts an integer between 0 and 100. */ - 'MemorySwappiness'?: number; + MemorySwappiness?: number; + /** - * CPU quota in units of 10-9 CPUs. + * CPU quota in units of 10<sup>-9</sup> CPUs. */ - 'NanoCpus'?: number; + NanoCpus?: number; + /** * Disable OOM Killer for the container. */ - 'OomKillDisable'?: boolean; + OomKillDisable?: boolean; + /** * Run an init inside the container that forwards signals and reaps processes. This field is omitted if empty, and the default (as configured on the daemon) is used. */ - 'Init'?: boolean | null; + Init?: boolean | null; + /** - * Tune a container\'s PIDs limit. Set `0` or `-1` for unlimited, or `null` to not change. + * Tune a container\'s PIDs limit. Set `0` or `-1` for unlimited, or `null` to not change. */ - 'PidsLimit'?: number | null; + PidsLimit?: number | null; + /** - * A list of resource limits to set in the container. For example: ``` {\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048} ``` + * A list of resource limits to set in the container. For example: ``` {\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048} ``` */ - 'Ulimits'?: Array; + Ulimits?: Array; + /** - * The number of usable CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. + * The number of usable CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. */ - 'CpuCount'?: number; + CpuCount?: number; + /** - * The usable percentage of the available CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. + * The usable percentage of the available CPUs (Windows only). On Windows Server containers, the processor resource controls are mutually exclusive. The order of precedence is `CPUCount` first, then `CPUShares`, and `CPUPercent` last. */ - 'CpuPercent'?: number; + CpuPercent?: number; + /** * Maximum IOps for the container system drive (Windows only) */ - 'IOMaximumIOps'?: number; + IOMaximumIOps?: number; + /** * Maximum IO in bytes per second for the container system drive (Windows only). */ - 'IOMaximumBandwidth'?: number; + IOMaximumBandwidth?: number; } diff --git a/src/models/ResourcesBlkioWeightDeviceInner.ts b/src/models/ResourcesBlkioWeightDeviceInner.ts index b330bc8..f0c295f 100644 --- a/src/models/ResourcesBlkioWeightDeviceInner.ts +++ b/src/models/ResourcesBlkioWeightDeviceInner.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ResourcesBlkioWeightDeviceInner { - 'Path'?: string; - 'Weight'?: number; +export interface ResourcesBlkioWeightDeviceInner { + Path?: string; + + Weight?: number; } diff --git a/src/models/ResourcesUlimitsInner.ts b/src/models/ResourcesUlimitsInner.ts index 3c1e2fd..10337dc 100644 --- a/src/models/ResourcesUlimitsInner.ts +++ b/src/models/ResourcesUlimitsInner.ts @@ -1,26 +1,36 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ResourcesUlimitsInner { +export interface ResourcesUlimitsInner { /** * Name of ulimit */ - 'Name'?: string; + Name?: string; + /** * Soft limit */ - 'Soft'?: number; + Soft?: number; + /** * Hard limit */ - 'Hard'?: number; + Hard?: number; } diff --git a/src/models/RestartPolicy.ts b/src/models/RestartPolicy.ts index 10af288..ed374d5 100644 --- a/src/models/RestartPolicy.ts +++ b/src/models/RestartPolicy.ts @@ -1,33 +1,41 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The behavior to apply when the container exits. The default is not to restart. An ever increasing delay (double the previous delay, starting at 100ms) is added before each restart to prevent flooding the server. */ -export class RestartPolicy { +export interface RestartPolicy { /** - * - Empty string means not to restart - `no` Do not automatically restart - `always` Always restart - `unless-stopped` Restart always except when the user has manually stopped the container - `on-failure` Restart only when the container exit code is non-zero + * - Empty string means not to restart - `no` Do not automatically restart - `always` Always restart - `unless-stopped` Restart always except when the user has manually stopped the container - `on-failure` Restart only when the container exit code is non-zero */ - 'Name'?: RestartPolicyNameEnum; + Name?: RestartPolicyNameEnum; + /** - * If `on-failure` is used, the number of times to retry before giving up. + * If `on-failure` is used, the number of times to retry before giving up. */ - 'MaximumRetryCount'?: number; + MaximumRetryCount?: number; } -export enum RestartPolicyNameEnum { - Empty = '', - No = 'no', - Always = 'always', - UnlessStopped = 'unless-stopped', - OnFailure = 'on-failure', -} +export type RestartPolicyNameEnum = + | '' + | 'no' + | 'always' + | 'unless-stopped' + | 'on-failure'; diff --git a/src/models/Runtime.ts b/src/models/Runtime.ts index 926ad38..66dd086 100644 --- a/src/models/Runtime.ts +++ b/src/models/Runtime.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Runtime describes an [OCI compliant](https://github.com/opencontainers/runtime-spec) runtime. The runtime is invoked by the daemon via the `containerd` daemon. OCI runtimes act as an interface to the Linux kernel namespaces, cgroups, and SELinux. */ -export class Runtime { +export interface Runtime { /** - * Name and, optional, path, of the OCI executable binary. If the path is omitted, the daemon searches the host\'s `$PATH` for the binary and uses the first result. + * Name and, optional, path, of the OCI executable binary. If the path is omitted, the daemon searches the host\'s `$PATH` for the binary and uses the first result. */ - 'Path'?: string; + Path?: string; + /** * List of command-line arguments to pass to the runtime when invoked. */ - 'RuntimeArgs'?: Array | null; + RuntimeArgs?: Array | null; + /** - * Information specific to the runtime. While this API specification does not define data provided by runtimes, the following well-known properties may be provided by runtimes: `org.opencontainers.runtime-spec.features`: features structure as defined in the [OCI Runtime Specification](https://github.com/opencontainers/runtime-spec/blob/main/features.md), in a JSON string representation.


> **Note**: The information returned in this field, including the > formatting of values and labels, should not be considered stable, > and may change without notice. + * Information specific to the runtime. While this API specification does not define data provided by runtimes, the following well-known properties may be provided by runtimes: `org.opencontainers.runtime-spec.features`: features structure as defined in the [OCI Runtime Specification](https://github.com/opencontainers/runtime-spec/blob/main/features.md), in a JSON string representation. <p><br /></p> > **Note**: The information returned in this field, including the > formatting of values and labels, should not be considered stable, > and may change without notice. */ - 'Status'?: { [key: string]: string } | null; + Status?: { [key: string]: string } | null; } diff --git a/src/models/Secret.ts b/src/models/Secret.ts index 703e597..3d16fc4 100644 --- a/src/models/Secret.ts +++ b/src/models/Secret.ts @@ -1,22 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ObjectVersion } from '../models/ObjectVersion.js'; import { SecretSpec } from '../models/SecretSpec.js'; -export class Secret { - 'ID'?: string; - 'Version'?: ObjectVersion; - 'CreatedAt'?: string; - 'UpdatedAt'?: string; - 'Spec'?: SecretSpec; +export interface Secret { + ID?: string; + + Version?: ObjectVersion; + + CreatedAt?: string; + + UpdatedAt?: string; + + Spec?: SecretSpec; } diff --git a/src/models/SecretCreateRequest.ts b/src/models/SecretCreateRequest.ts index 1924ca9..86f7151 100644 --- a/src/models/SecretCreateRequest.ts +++ b/src/models/SecretCreateRequest.ts @@ -1,30 +1,42 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Driver } from '../models/Driver.js'; -export class SecretCreateRequest { +export interface SecretCreateRequest { /** * User-defined name of the secret. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Data is the data to store as a secret, formatted as a Base64-url-safe-encoded ([RFC 4648](https://tools.ietf.org/html/rfc4648#section-5)) string. It must be empty if the Driver field is set, in which case the data is loaded from an external secret store. The maximum allowed size is 500KB, as defined in [MaxSecretSize](https://pkg.go.dev/github.com/moby/swarmkit/v2@v2.0.0/api/validation#MaxSecretSize). This field is only used to _create_ a secret, and is not returned by other endpoints. */ - 'Data'?: string; - 'Driver'?: Driver; - 'Templating'?: Driver; + Data?: string; + + Driver?: Driver; + + Templating?: Driver; } diff --git a/src/models/SecretSpec.ts b/src/models/SecretSpec.ts index 6c9519f..a870c2a 100644 --- a/src/models/SecretSpec.ts +++ b/src/models/SecretSpec.ts @@ -1,30 +1,42 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Driver } from '../models/Driver.js'; -export class SecretSpec { +export interface SecretSpec { /** * User-defined name of the secret. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * Data is the data to store as a secret, formatted as a Base64-url-safe-encoded ([RFC 4648](https://tools.ietf.org/html/rfc4648#section-5)) string. It must be empty if the Driver field is set, in which case the data is loaded from an external secret store. The maximum allowed size is 500KB, as defined in [MaxSecretSize](https://pkg.go.dev/github.com/moby/swarmkit/v2@v2.0.0/api/validation#MaxSecretSize). This field is only used to _create_ a secret, and is not returned by other endpoints. */ - 'Data'?: string; - 'Driver'?: Driver; - 'Templating'?: Driver; + Data?: string; + + Driver?: Driver; + + Templating?: Driver; } diff --git a/src/models/Service.ts b/src/models/Service.ts index c4ecd51..3d3dbcd 100644 --- a/src/models/Service.ts +++ b/src/models/Service.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ObjectVersion } from '../models/ObjectVersion.js'; @@ -17,14 +25,22 @@ import { ServiceServiceStatus } from '../models/ServiceServiceStatus.js'; import { ServiceSpec } from '../models/ServiceSpec.js'; import { ServiceUpdateStatus } from '../models/ServiceUpdateStatus.js'; -export class Service { - 'ID'?: string; - 'Version'?: ObjectVersion; - 'CreatedAt'?: string; - 'UpdatedAt'?: string; - 'Spec'?: ServiceSpec; - 'Endpoint'?: ServiceEndpoint; - 'UpdateStatus'?: ServiceUpdateStatus; - 'ServiceStatus'?: ServiceServiceStatus; - 'JobStatus'?: ServiceJobStatus; +export interface Service { + ID?: string; + + Version?: ObjectVersion; + + CreatedAt?: string; + + UpdatedAt?: string; + + Spec?: ServiceSpec; + + Endpoint?: ServiceEndpoint; + + UpdateStatus?: ServiceUpdateStatus; + + ServiceStatus?: ServiceServiceStatus; + + JobStatus?: ServiceJobStatus; } diff --git a/src/models/ServiceCreateRequest.ts b/src/models/ServiceCreateRequest.ts index b8e2215..04f9751 100644 --- a/src/models/ServiceCreateRequest.ts +++ b/src/models/ServiceCreateRequest.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointSpec } from '../models/EndpointSpec.js'; @@ -17,22 +25,29 @@ import { ServiceSpecRollbackConfig } from '../models/ServiceSpecRollbackConfig.j import { ServiceSpecUpdateConfig } from '../models/ServiceSpecUpdateConfig.js'; import { TaskSpec } from '../models/TaskSpec.js'; -export class ServiceCreateRequest { +export interface ServiceCreateRequest { /** * Name of the service. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'TaskTemplate'?: TaskSpec; - 'Mode'?: ServiceSpecMode; - 'UpdateConfig'?: ServiceSpecUpdateConfig; - 'RollbackConfig'?: ServiceSpecRollbackConfig; + Labels?: { [key: string]: string }; + + TaskTemplate?: TaskSpec; + + Mode?: ServiceSpecMode; + + UpdateConfig?: ServiceSpecUpdateConfig; + + RollbackConfig?: ServiceSpecRollbackConfig; + /** * Specifies which networks the service should attach to. Deprecated: This field is deprecated since v1.44. The Networks field in TaskSpec should be used instead. */ - 'Networks'?: Array; - 'EndpointSpec'?: EndpointSpec; + Networks?: Array; + + EndpointSpec?: EndpointSpec; } diff --git a/src/models/ServiceCreateResponse.ts b/src/models/ServiceCreateResponse.ts index 8c8596d..6273838 100644 --- a/src/models/ServiceCreateResponse.ts +++ b/src/models/ServiceCreateResponse.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * contains the information returned to a client on the creation of a new service. */ -export class ServiceCreateResponse { +export interface ServiceCreateResponse { /** * The ID of the created service. */ - 'ID'?: string; + ID?: string; + /** - * Optional warning message. FIXME(thaJeztah): this should have \"omitempty\" in the generated type. + * Optional warning message. FIXME(thaJeztah): this should have \"omitempty\" in the generated type. */ - 'Warnings'?: Array | null; + Warnings?: Array | null; } diff --git a/src/models/ServiceEndpoint.ts b/src/models/ServiceEndpoint.ts index 387e893..751314e 100644 --- a/src/models/ServiceEndpoint.ts +++ b/src/models/ServiceEndpoint.ts @@ -1,21 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointPortConfig } from '../models/EndpointPortConfig.js'; import { EndpointSpec } from '../models/EndpointSpec.js'; import { ServiceEndpointVirtualIPsInner } from '../models/ServiceEndpointVirtualIPsInner.js'; -export class ServiceEndpoint { - 'Spec'?: EndpointSpec; - 'Ports'?: Array; - 'VirtualIPs'?: Array; +export interface ServiceEndpoint { + Spec?: EndpointSpec; + + Ports?: Array; + + VirtualIPs?: Array; } diff --git a/src/models/ServiceEndpointVirtualIPsInner.ts b/src/models/ServiceEndpointVirtualIPsInner.ts index ad16412..7e03c68 100644 --- a/src/models/ServiceEndpointVirtualIPsInner.ts +++ b/src/models/ServiceEndpointVirtualIPsInner.ts @@ -1,16 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ServiceEndpointVirtualIPsInner { - 'NetworkID'?: string; - 'Addr'?: string; +export interface ServiceEndpointVirtualIPsInner { + NetworkID?: string; + + Addr?: string; } diff --git a/src/models/ServiceInfo.ts b/src/models/ServiceInfo.ts index 8933687..1d812cf 100644 --- a/src/models/ServiceInfo.ts +++ b/src/models/ServiceInfo.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { NetworkTaskInfo } from '../models/NetworkTaskInfo.js'; @@ -15,9 +23,12 @@ import { NetworkTaskInfo } from '../models/NetworkTaskInfo.js'; /** * represents service parameters with the list of service\'s tasks */ -export class ServiceInfo { - 'VIP'?: string; - 'Ports'?: Array; - 'LocalLBIndex'?: number; - 'Tasks'?: Array; +export interface ServiceInfo { + VIP?: string; + + Ports?: Array; + + LocalLBIndex?: number; + + Tasks?: Array; } diff --git a/src/models/ServiceJobStatus.ts b/src/models/ServiceJobStatus.ts index d0b6d17..7ecf181 100644 --- a/src/models/ServiceJobStatus.ts +++ b/src/models/ServiceJobStatus.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ObjectVersion } from '../models/ObjectVersion.js'; @@ -15,10 +23,11 @@ import { ObjectVersion } from '../models/ObjectVersion.js'; /** * The status of the service when it is in one of ReplicatedJob or GlobalJob modes. Absent on Replicated and Global mode services. The JobIteration is an ObjectVersion, but unlike the Service\'s version, does not need to be sent with an update request. */ -export class ServiceJobStatus { - 'JobIteration'?: ObjectVersion; +export interface ServiceJobStatus { + JobIteration?: ObjectVersion; + /** * The last time, as observed by the server, that this job was started. */ - 'LastExecution'?: string; + LastExecution?: string; } diff --git a/src/models/ServiceServiceStatus.ts b/src/models/ServiceServiceStatus.ts index 0ccc320..6ad3adf 100644 --- a/src/models/ServiceServiceStatus.ts +++ b/src/models/ServiceServiceStatus.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The status of the service\'s tasks. Provided only when requested as part of a ServiceList operation. */ -export class ServiceServiceStatus { +export interface ServiceServiceStatus { /** * The number of tasks for the service currently in the Running state. */ - 'RunningTasks'?: number; + RunningTasks?: number; + /** * The number of tasks for the service desired to be running. For replicated services, this is the replica count from the service spec. For global services, this is computed by taking count of all tasks for the service with a Desired State other than Shutdown. */ - 'DesiredTasks'?: number; + DesiredTasks?: number; + /** * The number of tasks for a job that are in the Completed state. This field must be cross-referenced with the service type, as the value of 0 may mean the service is not in a job mode, or it may mean the job-mode service has no tasks yet Completed. */ - 'CompletedTasks'?: number; + CompletedTasks?: number; } diff --git a/src/models/ServiceSpec.ts b/src/models/ServiceSpec.ts index d98dc57..ff2421f 100644 --- a/src/models/ServiceSpec.ts +++ b/src/models/ServiceSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointSpec } from '../models/EndpointSpec.js'; @@ -20,22 +28,29 @@ import { TaskSpec } from '../models/TaskSpec.js'; /** * User modifiable configuration for a service. */ -export class ServiceSpec { +export interface ServiceSpec { /** * Name of the service. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'TaskTemplate'?: TaskSpec; - 'Mode'?: ServiceSpecMode; - 'UpdateConfig'?: ServiceSpecUpdateConfig; - 'RollbackConfig'?: ServiceSpecRollbackConfig; + Labels?: { [key: string]: string }; + + TaskTemplate?: TaskSpec; + + Mode?: ServiceSpecMode; + + UpdateConfig?: ServiceSpecUpdateConfig; + + RollbackConfig?: ServiceSpecRollbackConfig; + /** * Specifies which networks the service should attach to. Deprecated: This field is deprecated since v1.44. The Networks field in TaskSpec should be used instead. */ - 'Networks'?: Array; - 'EndpointSpec'?: EndpointSpec; + Networks?: Array; + + EndpointSpec?: EndpointSpec; } diff --git a/src/models/ServiceSpecMode.ts b/src/models/ServiceSpecMode.ts index 72e3d5a..0c061a1 100644 --- a/src/models/ServiceSpecMode.ts +++ b/src/models/ServiceSpecMode.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ServiceSpecModeReplicated } from '../models/ServiceSpecModeReplicated.js'; @@ -16,12 +24,15 @@ import { ServiceSpecModeReplicatedJob } from '../models/ServiceSpecModeReplicate /** * Scheduling mode for the service. */ -export class ServiceSpecMode { - 'Replicated'?: ServiceSpecModeReplicated; - 'Global'?: any; - 'ReplicatedJob'?: ServiceSpecModeReplicatedJob; +export interface ServiceSpecMode { + Replicated?: ServiceSpecModeReplicated; + + Global?: any; + + ReplicatedJob?: ServiceSpecModeReplicatedJob; + /** * The mode used for services which run a task to the completed state on each valid node. */ - 'GlobalJob'?: any; + GlobalJob?: any; } diff --git a/src/models/ServiceSpecModeReplicated.ts b/src/models/ServiceSpecModeReplicated.ts index 3e90fed..0e41908 100644 --- a/src/models/ServiceSpecModeReplicated.ts +++ b/src/models/ServiceSpecModeReplicated.ts @@ -1,15 +1,23 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ServiceSpecModeReplicated { - 'Replicas'?: number; +export interface ServiceSpecModeReplicated { + Replicas?: number; } diff --git a/src/models/ServiceSpecModeReplicatedJob.ts b/src/models/ServiceSpecModeReplicatedJob.ts index 2ea3ba5..fef8127 100644 --- a/src/models/ServiceSpecModeReplicatedJob.ts +++ b/src/models/ServiceSpecModeReplicatedJob.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The mode used for services with a finite number of tasks that run to a completed state. */ -export class ServiceSpecModeReplicatedJob { +export interface ServiceSpecModeReplicatedJob { /** * The maximum number of replicas to run simultaneously. */ - 'MaxConcurrent'?: number; + MaxConcurrent?: number; + /** - * The total number of replicas desired to reach the Completed state. If unset, will default to the value of `MaxConcurrent` + * The total number of replicas desired to reach the Completed state. If unset, will default to the value of `MaxConcurrent` */ - 'TotalCompletions'?: number; + TotalCompletions?: number; } diff --git a/src/models/ServiceSpecRollbackConfig.ts b/src/models/ServiceSpecRollbackConfig.ts index b0b460d..3d40f15 100644 --- a/src/models/ServiceSpecRollbackConfig.ts +++ b/src/models/ServiceSpecRollbackConfig.ts @@ -1,50 +1,57 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Specification for the rollback strategy of the service. */ -export class ServiceSpecRollbackConfig { +export interface ServiceSpecRollbackConfig { /** * Maximum number of tasks to be rolled back in one iteration (0 means unlimited parallelism). */ - 'Parallelism'?: number; + Parallelism?: number; + /** * Amount of time between rollback iterations, in nanoseconds. */ - 'Delay'?: number; + Delay?: number; + /** * Action to take if an rolled back task fails to run, or stops running during the rollback. */ - 'FailureAction'?: ServiceSpecRollbackConfigFailureActionEnum; + FailureAction?: ServiceSpecRollbackConfigFailureActionEnum; + /** * Amount of time to monitor each rolled back task for failures, in nanoseconds. */ - 'Monitor'?: number; + Monitor?: number; + /** * The fraction of tasks that may fail during a rollback before the failure action is invoked, specified as a floating point number between 0 and 1. */ - 'MaxFailureRatio'?: number; + MaxFailureRatio?: number; + /** * The order of operations when rolling back a task. Either the old task is shut down before the new task is started, or the new task is started before the old task is shut down. */ - 'Order'?: ServiceSpecRollbackConfigOrderEnum; + Order?: ServiceSpecRollbackConfigOrderEnum; } -export enum ServiceSpecRollbackConfigFailureActionEnum { - Continue = 'continue', - Pause = 'pause', -} -export enum ServiceSpecRollbackConfigOrderEnum { - StopFirst = 'stop-first', - StartFirst = 'start-first', -} +export type ServiceSpecRollbackConfigFailureActionEnum = 'continue' | 'pause'; +export type ServiceSpecRollbackConfigOrderEnum = 'stop-first' | 'start-first'; diff --git a/src/models/ServiceSpecUpdateConfig.ts b/src/models/ServiceSpecUpdateConfig.ts index 33cf211..3c629e4 100644 --- a/src/models/ServiceSpecUpdateConfig.ts +++ b/src/models/ServiceSpecUpdateConfig.ts @@ -1,51 +1,60 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Specification for the update strategy of the service. */ -export class ServiceSpecUpdateConfig { +export interface ServiceSpecUpdateConfig { /** * Maximum number of tasks to be updated in one iteration (0 means unlimited parallelism). */ - 'Parallelism'?: number; + Parallelism?: number; + /** * Amount of time between updates, in nanoseconds. */ - 'Delay'?: number; + Delay?: number; + /** * Action to take if an updated task fails to run, or stops running during the update. */ - 'FailureAction'?: ServiceSpecUpdateConfigFailureActionEnum; + FailureAction?: ServiceSpecUpdateConfigFailureActionEnum; + /** * Amount of time to monitor each updated task for failures, in nanoseconds. */ - 'Monitor'?: number; + Monitor?: number; + /** * The fraction of tasks that may fail during an update before the failure action is invoked, specified as a floating point number between 0 and 1. */ - 'MaxFailureRatio'?: number; + MaxFailureRatio?: number; + /** * The order of operations when rolling out an updated task. Either the old task is shut down before the new task is started, or the new task is started before the old task is shut down. */ - 'Order'?: ServiceSpecUpdateConfigOrderEnum; + Order?: ServiceSpecUpdateConfigOrderEnum; } -export enum ServiceSpecUpdateConfigFailureActionEnum { - Continue = 'continue', - Pause = 'pause', - Rollback = 'rollback', -} -export enum ServiceSpecUpdateConfigOrderEnum { - StopFirst = 'stop-first', - StartFirst = 'start-first', -} +export type ServiceSpecUpdateConfigFailureActionEnum = + | 'continue' + | 'pause' + | 'rollback'; +export type ServiceSpecUpdateConfigOrderEnum = 'stop-first' | 'start-first'; diff --git a/src/models/ServiceUpdateRequest.ts b/src/models/ServiceUpdateRequest.ts index 9bef89b..3e5b95b 100644 --- a/src/models/ServiceUpdateRequest.ts +++ b/src/models/ServiceUpdateRequest.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { EndpointSpec } from '../models/EndpointSpec.js'; @@ -17,22 +25,29 @@ import { ServiceSpecRollbackConfig } from '../models/ServiceSpecRollbackConfig.j import { ServiceSpecUpdateConfig } from '../models/ServiceSpecUpdateConfig.js'; import { TaskSpec } from '../models/TaskSpec.js'; -export class ServiceUpdateRequest { +export interface ServiceUpdateRequest { /** * Name of the service. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'TaskTemplate'?: TaskSpec; - 'Mode'?: ServiceSpecMode; - 'UpdateConfig'?: ServiceSpecUpdateConfig; - 'RollbackConfig'?: ServiceSpecRollbackConfig; + Labels?: { [key: string]: string }; + + TaskTemplate?: TaskSpec; + + Mode?: ServiceSpecMode; + + UpdateConfig?: ServiceSpecUpdateConfig; + + RollbackConfig?: ServiceSpecRollbackConfig; + /** * Specifies which networks the service should attach to. Deprecated: This field is deprecated since v1.44. The Networks field in TaskSpec should be used instead. */ - 'Networks'?: Array; - 'EndpointSpec'?: EndpointSpec; + Networks?: Array; + + EndpointSpec?: EndpointSpec; } diff --git a/src/models/ServiceUpdateResponse.ts b/src/models/ServiceUpdateResponse.ts index 2742e15..fa1052a 100644 --- a/src/models/ServiceUpdateResponse.ts +++ b/src/models/ServiceUpdateResponse.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ServiceUpdateResponse { +export interface ServiceUpdateResponse { /** * Optional warning messages */ - 'Warnings'?: Array; + Warnings?: Array; } diff --git a/src/models/ServiceUpdateStatus.ts b/src/models/ServiceUpdateStatus.ts index f3d75cf..5810ea0 100644 --- a/src/models/ServiceUpdateStatus.ts +++ b/src/models/ServiceUpdateStatus.ts @@ -1,27 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The status of a service update. */ -export class ServiceUpdateStatus { - 'State'?: ServiceUpdateStatusStateEnum; - 'StartedAt'?: string; - 'CompletedAt'?: string; - 'Message'?: string; -} +export interface ServiceUpdateStatus { + State?: ServiceUpdateStatusStateEnum; + + StartedAt?: string; -export enum ServiceUpdateStatusStateEnum { - Updating = 'updating', - Paused = 'paused', - Completed = 'completed', + CompletedAt?: string; + + Message?: string; } + +export type ServiceUpdateStatusStateEnum = 'updating' | 'paused' | 'completed'; diff --git a/src/models/Swarm.ts b/src/models/Swarm.ts index 60a704b..6a33bd8 100644 --- a/src/models/Swarm.ts +++ b/src/models/Swarm.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { JoinTokens } from '../models/JoinTokens.js'; @@ -15,37 +23,47 @@ import { ObjectVersion } from '../models/ObjectVersion.js'; import { SwarmSpec } from '../models/SwarmSpec.js'; import { TLSInfo } from '../models/TLSInfo.js'; -export class Swarm { +export interface Swarm { /** * The ID of the swarm. */ - 'ID'?: string; - 'Version'?: ObjectVersion; + ID?: string; + + Version?: ObjectVersion; + /** * Date and time at which the swarm was initialised in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'CreatedAt'?: string; + CreatedAt?: string; + /** * Date and time at which the swarm was last updated in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'UpdatedAt'?: string; - 'Spec'?: SwarmSpec; - 'TLSInfo'?: TLSInfo; + UpdatedAt?: string; + + Spec?: SwarmSpec; + + TLSInfo?: TLSInfo; + /** * Whether there is currently a root CA rotation in progress for the swarm */ - 'RootRotationInProgress'?: boolean; + RootRotationInProgress?: boolean; + /** * DataPathPort specifies the data path port number for data traffic. Acceptable port range is 1024 to 49151. If no port is set or is set to 0, the default port (4789) is used. */ - 'DataPathPort'?: number; + DataPathPort?: number; + /** * Default Address Pool specifies default subnet pools for global scope networks. */ - 'DefaultAddrPool'?: Array; + DefaultAddrPool?: Array; + /** * SubnetSize specifies the subnet size of the networks created from the default subnet pool. */ - 'SubnetSize'?: number; - 'JoinTokens'?: JoinTokens; + SubnetSize?: number; + + JoinTokens?: JoinTokens; } diff --git a/src/models/SwarmInfo.ts b/src/models/SwarmInfo.ts index 833008e..7d5a0e3 100644 --- a/src/models/SwarmInfo.ts +++ b/src/models/SwarmInfo.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterInfo } from '../models/ClusterInfo.js'; @@ -17,29 +25,37 @@ import { PeerNode } from '../models/PeerNode.js'; /** * Represents generic information about swarm. */ -export class SwarmInfo { +export interface SwarmInfo { /** * Unique identifier of for this node in the swarm. */ - 'NodeID'?: string; + NodeID?: string; + /** * IP address at which this node can be reached by other nodes in the swarm. */ - 'NodeAddr'?: string; - 'LocalNodeState'?: LocalNodeState; - 'ControlAvailable'?: boolean; - 'Error'?: string; + NodeAddr?: string; + + LocalNodeState?: LocalNodeState; + + ControlAvailable?: boolean; + + Error?: string; + /** - * List of ID\'s and addresses of other managers in the swarm. + * List of ID\'s and addresses of other managers in the swarm. */ - 'RemoteManagers'?: Array | null; + RemoteManagers?: Array | null; + /** * Total number of nodes in the swarm. */ - 'Nodes'?: number | null; + Nodes?: number | null; + /** * Total number of managers in the swarm. */ - 'Managers'?: number | null; - 'Cluster'?: ClusterInfo | null; + Managers?: number | null; + + Cluster?: ClusterInfo | null; } diff --git a/src/models/SwarmInitRequest.ts b/src/models/SwarmInitRequest.ts index 11a22eb..50e8e2b 100644 --- a/src/models/SwarmInitRequest.ts +++ b/src/models/SwarmInitRequest.ts @@ -1,45 +1,60 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { SwarmSpec } from '../models/SwarmSpec.js'; -export class SwarmInitRequest { +export interface SwarmInitRequest { /** - * Listen address used for inter-manager communication, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). This can either be an address/port combination in the form `192.168.1.1:4567`, or an interface followed by a port number, like `eth0:4567`. If the port number is omitted, the default swarm listening port is used. + * Listen address used for inter-manager communication, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). This can either be an address/port combination in the form `192.168.1.1:4567`, or an interface followed by a port number, like `eth0:4567`. If the port number is omitted, the default swarm listening port is used. */ - 'ListenAddr'?: string; + ListenAddr?: string; + /** - * Externally reachable address advertised to other nodes. This can either be an address/port combination in the form `192.168.1.1:4567`, or an interface followed by a port number, like `eth0:4567`. If the port number is omitted, the port number from the listen address is used. If `AdvertiseAddr` is not specified, it will be automatically detected when possible. + * Externally reachable address advertised to other nodes. This can either be an address/port combination in the form `192.168.1.1:4567`, or an interface followed by a port number, like `eth0:4567`. If the port number is omitted, the port number from the listen address is used. If `AdvertiseAddr` is not specified, it will be automatically detected when possible. */ - 'AdvertiseAddr'?: string; + AdvertiseAddr?: string; + /** - * Address or interface to use for data path traffic (format: ``), for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is unspecified, the same address as `AdvertiseAddr` is used. The `DataPathAddr` specifies the address that global scope network drivers will publish towards other nodes in order to reach the containers running on this node. Using this parameter it is possible to separate the container data traffic from the management traffic of the cluster. + * Address or interface to use for data path traffic (format: `<ip|interface>`), for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is unspecified, the same address as `AdvertiseAddr` is used. The `DataPathAddr` specifies the address that global scope network drivers will publish towards other nodes in order to reach the containers running on this node. Using this parameter it is possible to separate the container data traffic from the management traffic of the cluster. */ - 'DataPathAddr'?: string; + DataPathAddr?: string; + /** * DataPathPort specifies the data path port number for data traffic. Acceptable port range is 1024 to 49151. if no port is set or is set to 0, default port 4789 will be used. */ - 'DataPathPort'?: number; + DataPathPort?: number; + /** * Default Address Pool specifies default subnet pools for global scope networks. */ - 'DefaultAddrPool'?: Array; + DefaultAddrPool?: Array; + /** * Force creation of a new swarm. */ - 'ForceNewCluster'?: boolean; + ForceNewCluster?: boolean; + /** * SubnetSize specifies the subnet size of the networks created from the default subnet pool. */ - 'SubnetSize'?: number; - 'Spec'?: SwarmSpec; + SubnetSize?: number; + + Spec?: SwarmSpec; } diff --git a/src/models/SwarmJoinRequest.ts b/src/models/SwarmJoinRequest.ts index 5a5bf57..2877937 100644 --- a/src/models/SwarmJoinRequest.ts +++ b/src/models/SwarmJoinRequest.ts @@ -1,34 +1,46 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SwarmJoinRequest { +export interface SwarmJoinRequest { /** * Listen address used for inter-manager communication if the node gets promoted to manager, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). */ - 'ListenAddr'?: string; + ListenAddr?: string; + /** - * Externally reachable address advertised to other nodes. This can either be an address/port combination in the form `192.168.1.1:4567`, or an interface followed by a port number, like `eth0:4567`. If the port number is omitted, the port number from the listen address is used. If `AdvertiseAddr` is not specified, it will be automatically detected when possible. + * Externally reachable address advertised to other nodes. This can either be an address/port combination in the form `192.168.1.1:4567`, or an interface followed by a port number, like `eth0:4567`. If the port number is omitted, the port number from the listen address is used. If `AdvertiseAddr` is not specified, it will be automatically detected when possible. */ - 'AdvertiseAddr'?: string; + AdvertiseAddr?: string; + /** - * Address or interface to use for data path traffic (format: ``), for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is unspecified, the same address as `AdvertiseAddr` is used. The `DataPathAddr` specifies the address that global scope network drivers will publish towards other nodes in order to reach the containers running on this node. Using this parameter it is possible to separate the container data traffic from the management traffic of the cluster. + * Address or interface to use for data path traffic (format: `<ip|interface>`), for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is unspecified, the same address as `AdvertiseAddr` is used. The `DataPathAddr` specifies the address that global scope network drivers will publish towards other nodes in order to reach the containers running on this node. Using this parameter it is possible to separate the container data traffic from the management traffic of the cluster. */ - 'DataPathAddr'?: string; + DataPathAddr?: string; + /** * Addresses of manager nodes already participating in the swarm. */ - 'RemoteAddrs'?: Array; + RemoteAddrs?: Array; + /** * Secret token for joining this swarm. */ - 'JoinToken'?: string; + JoinToken?: string; } diff --git a/src/models/SwarmSpec.ts b/src/models/SwarmSpec.ts index 10f8da2..701551c 100644 --- a/src/models/SwarmSpec.ts +++ b/src/models/SwarmSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { SwarmSpecCAConfig } from '../models/SwarmSpecCAConfig.js'; @@ -20,19 +28,26 @@ import { SwarmSpecTaskDefaults } from '../models/SwarmSpecTaskDefaults.js'; /** * User modifiable swarm configuration. */ -export class SwarmSpec { +export interface SwarmSpec { /** * Name of the swarm. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'Orchestration'?: SwarmSpecOrchestration | null; - 'Raft'?: SwarmSpecRaft; - 'Dispatcher'?: SwarmSpecDispatcher | null; - 'CAConfig'?: SwarmSpecCAConfig | null; - 'EncryptionConfig'?: SwarmSpecEncryptionConfig; - 'TaskDefaults'?: SwarmSpecTaskDefaults; + Labels?: { [key: string]: string }; + + Orchestration?: SwarmSpecOrchestration | null; + + Raft?: SwarmSpecRaft; + + Dispatcher?: SwarmSpecDispatcher | null; + + CAConfig?: SwarmSpecCAConfig | null; + + EncryptionConfig?: SwarmSpecEncryptionConfig; + + TaskDefaults?: SwarmSpecTaskDefaults; } diff --git a/src/models/SwarmSpecCAConfig.ts b/src/models/SwarmSpecCAConfig.ts index 2282776..ce0b0ab 100644 --- a/src/models/SwarmSpecCAConfig.ts +++ b/src/models/SwarmSpecCAConfig.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { SwarmSpecCAConfigExternalCAsInner } from '../models/SwarmSpecCAConfigExternalCAsInner.js'; @@ -15,25 +23,29 @@ import { SwarmSpecCAConfigExternalCAsInner } from '../models/SwarmSpecCAConfigEx /** * CA configuration. */ -export class SwarmSpecCAConfig { +export interface SwarmSpecCAConfig { /** * The duration node certificates are issued for. */ - 'NodeCertExpiry'?: number; + NodeCertExpiry?: number; + /** * Configuration for forwarding signing requests to an external certificate authority. */ - 'ExternalCAs'?: Array; + ExternalCAs?: Array; + /** * The desired signing CA certificate for all swarm node TLS leaf certificates, in PEM format. */ - 'SigningCACert'?: string; + SigningCACert?: string; + /** * The desired signing CA key for all swarm node TLS leaf certificates, in PEM format. */ - 'SigningCAKey'?: string; + SigningCAKey?: string; + /** - * An integer whose purpose is to force swarm to generate a new signing CA certificate and key, if none have been specified in `SigningCACert` and `SigningCAKey` + * An integer whose purpose is to force swarm to generate a new signing CA certificate and key, if none have been specified in `SigningCACert` and `SigningCAKey` */ - 'ForceRotate'?: number; + ForceRotate?: number; } diff --git a/src/models/SwarmSpecCAConfigExternalCAsInner.ts b/src/models/SwarmSpecCAConfigExternalCAsInner.ts index e4ba847..59c3e5e 100644 --- a/src/models/SwarmSpecCAConfigExternalCAsInner.ts +++ b/src/models/SwarmSpecCAConfigExternalCAsInner.ts @@ -1,34 +1,43 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SwarmSpecCAConfigExternalCAsInner { +export interface SwarmSpecCAConfigExternalCAsInner { /** - * Protocol for communication with the external CA (currently only `cfssl` is supported). + * Protocol for communication with the external CA (currently only `cfssl` is supported). */ - 'Protocol'?: SwarmSpecCAConfigExternalCAsInnerProtocolEnum; + Protocol?: SwarmSpecCAConfigExternalCAsInnerProtocolEnum; + /** * URL where certificate signing requests should be sent. */ - 'URL'?: string; + URL?: string; + /** * An object with key/value pairs that are interpreted as protocol-specific options for the external CA driver. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; + /** * The root CA certificate (in PEM format) this external CA uses to issue TLS certificates (assumed to be to the current swarm root CA certificate if not provided). */ - 'CACert'?: string; + CACert?: string; } -export enum SwarmSpecCAConfigExternalCAsInnerProtocolEnum { - Cfssl = 'cfssl', -} +export type SwarmSpecCAConfigExternalCAsInnerProtocolEnum = 'cfssl'; diff --git a/src/models/SwarmSpecDispatcher.ts b/src/models/SwarmSpecDispatcher.ts index 1ee3003..e1292b9 100644 --- a/src/models/SwarmSpecDispatcher.ts +++ b/src/models/SwarmSpecDispatcher.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Dispatcher configuration. */ -export class SwarmSpecDispatcher { +export interface SwarmSpecDispatcher { /** * The delay for an agent to send a heartbeat to the dispatcher. */ - 'HeartbeatPeriod'?: number; + HeartbeatPeriod?: number; } diff --git a/src/models/SwarmSpecEncryptionConfig.ts b/src/models/SwarmSpecEncryptionConfig.ts index 5e6a620..7b83cd8 100644 --- a/src/models/SwarmSpecEncryptionConfig.ts +++ b/src/models/SwarmSpecEncryptionConfig.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Parameters related to encryption-at-rest. */ -export class SwarmSpecEncryptionConfig { +export interface SwarmSpecEncryptionConfig { /** * If set, generate a key and use it to lock data stored on the managers. */ - 'AutoLockManagers'?: boolean; + AutoLockManagers?: boolean; } diff --git a/src/models/SwarmSpecOrchestration.ts b/src/models/SwarmSpecOrchestration.ts index 3ab79f6..a8431f5 100644 --- a/src/models/SwarmSpecOrchestration.ts +++ b/src/models/SwarmSpecOrchestration.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Orchestration configuration. */ -export class SwarmSpecOrchestration { +export interface SwarmSpecOrchestration { /** * The number of historic tasks to keep per instance or node. If negative, never remove completed or failed tasks. */ - 'TaskHistoryRetentionLimit'?: number; + TaskHistoryRetentionLimit?: number; } diff --git a/src/models/SwarmSpecRaft.ts b/src/models/SwarmSpecRaft.ts index 1d1ddbd..be2c6af 100644 --- a/src/models/SwarmSpecRaft.ts +++ b/src/models/SwarmSpecRaft.ts @@ -1,37 +1,49 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Raft configuration. */ -export class SwarmSpecRaft { +export interface SwarmSpecRaft { /** * The number of log entries between snapshots. */ - 'SnapshotInterval'?: number; + SnapshotInterval?: number; + /** * The number of snapshots to keep beyond the current snapshot. */ - 'KeepOldSnapshots'?: number; + KeepOldSnapshots?: number; + /** * The number of log entries to keep around to sync up slow followers after a snapshot is created. */ - 'LogEntriesForSlowFollowers'?: number; + LogEntriesForSlowFollowers?: number; + /** - * The number of ticks that a follower will wait for a message from the leader before becoming a candidate and starting an election. `ElectionTick` must be greater than `HeartbeatTick`. A tick currently defaults to one second, so these translate directly to seconds currently, but this is NOT guaranteed. + * The number of ticks that a follower will wait for a message from the leader before becoming a candidate and starting an election. `ElectionTick` must be greater than `HeartbeatTick`. A tick currently defaults to one second, so these translate directly to seconds currently, but this is NOT guaranteed. */ - 'ElectionTick'?: number; + ElectionTick?: number; + /** * The number of ticks between heartbeats. Every HeartbeatTick ticks, the leader will send a heartbeat to the followers. A tick currently defaults to one second, so these translate directly to seconds currently, but this is NOT guaranteed. */ - 'HeartbeatTick'?: number; + HeartbeatTick?: number; } diff --git a/src/models/SwarmSpecTaskDefaults.ts b/src/models/SwarmSpecTaskDefaults.ts index de9cc8b..08504ba 100644 --- a/src/models/SwarmSpecTaskDefaults.ts +++ b/src/models/SwarmSpecTaskDefaults.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { SwarmSpecTaskDefaultsLogDriver } from '../models/SwarmSpecTaskDefaultsLogDriver.js'; @@ -15,6 +23,6 @@ import { SwarmSpecTaskDefaultsLogDriver } from '../models/SwarmSpecTaskDefaultsL /** * Defaults for creating tasks in this cluster. */ -export class SwarmSpecTaskDefaults { - 'LogDriver'?: SwarmSpecTaskDefaultsLogDriver; +export interface SwarmSpecTaskDefaults { + LogDriver?: SwarmSpecTaskDefaultsLogDriver; } diff --git a/src/models/SwarmSpecTaskDefaultsLogDriver.ts b/src/models/SwarmSpecTaskDefaultsLogDriver.ts index 3e5fb55..e1ff497 100644 --- a/src/models/SwarmSpecTaskDefaultsLogDriver.ts +++ b/src/models/SwarmSpecTaskDefaultsLogDriver.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * The log driver to use for tasks created in the orchestrator if unspecified by a service. Updating this value only affects new tasks. Existing tasks continue to use their previously configured log driver until recreated. */ -export class SwarmSpecTaskDefaultsLogDriver { +export interface SwarmSpecTaskDefaultsLogDriver { /** * The log driver to use as a default for new tasks. */ - 'Name'?: string; + Name?: string; + /** * Driver-specific options for the selected log driver, specified as key/value pairs. */ - 'Options'?: { [key: string]: string }; + Options?: { [key: string]: string }; } diff --git a/src/models/SwarmUnlockRequest.ts b/src/models/SwarmUnlockRequest.ts index 8c27873..608b88e 100644 --- a/src/models/SwarmUnlockRequest.ts +++ b/src/models/SwarmUnlockRequest.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SwarmUnlockRequest { +export interface SwarmUnlockRequest { /** - * The swarm\'s unlock key. + * The swarm\'s unlock key. */ - 'UnlockKey'?: string; + UnlockKey?: string; } diff --git a/src/models/SystemAuthResponse.ts b/src/models/SystemAuthResponse.ts index d426aed..fbff9bc 100644 --- a/src/models/SystemAuthResponse.ts +++ b/src/models/SystemAuthResponse.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SystemAuthResponse { +export interface SystemAuthResponse { /** * The status of the authentication */ - 'Status': string; + Status: string; + /** * An opaque token used to authenticate a user after a successful login */ - 'IdentityToken'?: string; + IdentityToken?: string; } diff --git a/src/models/SystemDataUsageResponse.ts b/src/models/SystemDataUsageResponse.ts index 01ac437..3f6a99a 100644 --- a/src/models/SystemDataUsageResponse.ts +++ b/src/models/SystemDataUsageResponse.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { BuildCache } from '../models/BuildCache.js'; @@ -15,10 +23,14 @@ import { ContainerSummary } from '../models/ContainerSummary.js'; import { ImageSummary } from '../models/ImageSummary.js'; import { Volume } from '../models/Volume.js'; -export class SystemDataUsageResponse { - 'LayersSize'?: number; - 'Images'?: Array; - 'Containers'?: Array; - 'Volumes'?: Array; - 'BuildCache'?: Array; +export interface SystemDataUsageResponse { + LayersSize?: number; + + Images?: Array; + + Containers?: Array; + + Volumes?: Array; + + BuildCache?: Array; } diff --git a/src/models/SystemInfo.ts b/src/models/SystemInfo.ts index d1fa71e..abaeedf 100644 --- a/src/models/SystemInfo.ts +++ b/src/models/SystemInfo.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Commit } from '../models/Commit.js'; @@ -21,253 +29,304 @@ import { Runtime } from '../models/Runtime.js'; import { SwarmInfo } from '../models/SwarmInfo.js'; import { SystemInfoDefaultAddressPoolsInner } from '../models/SystemInfoDefaultAddressPoolsInner.js'; -export class SystemInfo { +export interface SystemInfo { /** - * Unique identifier of the daemon.


> **Note**: The format of the ID itself is not part of the API, and > should not be considered stable. + * Unique identifier of the daemon. <p><br /></p> > **Note**: The format of the ID itself is not part of the API, and > should not be considered stable. */ - 'ID'?: string; + ID?: string; + /** * Total number of containers on the host. */ - 'Containers'?: number; + Containers?: number; + /** - * Number of containers with status `\"running\"`. + * Number of containers with status `\"running\"`. */ - 'ContainersRunning'?: number; + ContainersRunning?: number; + /** - * Number of containers with status `\"paused\"`. + * Number of containers with status `\"paused\"`. */ - 'ContainersPaused'?: number; + ContainersPaused?: number; + /** - * Number of containers with status `\"stopped\"`. + * Number of containers with status `\"stopped\"`. */ - 'ContainersStopped'?: number; + ContainersStopped?: number; + /** * Total number of images on the host. Both _tagged_ and _untagged_ (dangling) images are counted. */ - 'Images'?: number; + Images?: number; + /** * Name of the storage driver in use. */ - 'Driver'?: string; + Driver?: string; + /** - * Information specific to the storage driver, provided as \"label\" / \"value\" pairs. This information is provided by the storage driver, and formatted in a way consistent with the output of `docker info` on the command line.


> **Note**: The information returned in this field, including the > formatting of values and labels, should not be considered stable, > and may change without notice. + * Information specific to the storage driver, provided as \"label\" / \"value\" pairs. This information is provided by the storage driver, and formatted in a way consistent with the output of `docker info` on the command line. <p><br /></p> > **Note**: The information returned in this field, including the > formatting of values and labels, should not be considered stable, > and may change without notice. */ - 'DriverStatus'?: Array>; + DriverStatus?: Array>; + /** - * Root directory of persistent Docker state. Defaults to `/var/lib/docker` on Linux, and `C:\\ProgramData\\docker` on Windows. + * Root directory of persistent Docker state. Defaults to `/var/lib/docker` on Linux, and `C:\\ProgramData\\docker` on Windows. */ - 'DockerRootDir'?: string; - 'Plugins'?: PluginsInfo; + DockerRootDir?: string; + + Plugins?: PluginsInfo; + /** * Indicates if the host has memory limit support enabled. */ - 'MemoryLimit'?: boolean; + MemoryLimit?: boolean; + /** * Indicates if the host has memory swap limit support enabled. */ - 'SwapLimit'?: boolean; + SwapLimit?: boolean; + /** - * Indicates if the host has kernel memory TCP limit support enabled. This field is omitted if not supported. Kernel memory TCP limits are not supported when using cgroups v2, which does not support the corresponding `memory.kmem.tcp.limit_in_bytes` cgroup. + * Indicates if the host has kernel memory TCP limit support enabled. This field is omitted if not supported. Kernel memory TCP limits are not supported when using cgroups v2, which does not support the corresponding `memory.kmem.tcp.limit_in_bytes` cgroup. */ - 'KernelMemoryTCP'?: boolean; + KernelMemoryTCP?: boolean; + /** * Indicates if CPU CFS(Completely Fair Scheduler) period is supported by the host. */ - 'CpuCfsPeriod'?: boolean; + CpuCfsPeriod?: boolean; + /** * Indicates if CPU CFS(Completely Fair Scheduler) quota is supported by the host. */ - 'CpuCfsQuota'?: boolean; + CpuCfsQuota?: boolean; + /** * Indicates if CPU Shares limiting is supported by the host. */ - 'CPUShares'?: boolean; + CPUShares?: boolean; + /** * Indicates if CPUsets (cpuset.cpus, cpuset.mems) are supported by the host. See [cpuset(7)](https://www.kernel.org/doc/Documentation/cgroup-v1/cpusets.txt) */ - 'CPUSet'?: boolean; + CPUSet?: boolean; + /** * Indicates if the host kernel has PID limit support enabled. */ - 'PidsLimit'?: boolean; + PidsLimit?: boolean; + /** * Indicates if OOM killer disable is supported on the host. */ - 'OomKillDisable'?: boolean; + OomKillDisable?: boolean; + /** * Indicates IPv4 forwarding is enabled. */ - 'IPv4Forwarding'?: boolean; + IPv4Forwarding?: boolean; + /** - * Indicates if `bridge-nf-call-iptables` is available on the host when the daemon was started.


> **Deprecated**: netfilter module is now loaded on-demand and no longer > during daemon startup, making this field obsolete. This field is always > `false` and will be removed in a API v1.49. + * Indicates if `bridge-nf-call-iptables` is available on the host when the daemon was started. <p><br /></p> > **Deprecated**: netfilter module is now loaded on-demand and no longer > during daemon startup, making this field obsolete. This field is always > `false` and will be removed in a API v1.49. */ - 'BridgeNfIptables'?: boolean; + BridgeNfIptables?: boolean; + /** - * Indicates if `bridge-nf-call-ip6tables` is available on the host.


> **Deprecated**: netfilter module is now loaded on-demand, and no longer > during daemon startup, making this field obsolete. This field is always > `false` and will be removed in a API v1.49. + * Indicates if `bridge-nf-call-ip6tables` is available on the host. <p><br /></p> > **Deprecated**: netfilter module is now loaded on-demand, and no longer > during daemon startup, making this field obsolete. This field is always > `false` and will be removed in a API v1.49. */ - 'BridgeNfIp6tables'?: boolean; + BridgeNfIp6tables?: boolean; + /** * Indicates if the daemon is running in debug-mode / with debug-level logging enabled. */ - 'Debug'?: boolean; + Debug?: boolean; + /** * The total number of file Descriptors in use by the daemon process. This information is only returned if debug-mode is enabled. */ - 'NFd'?: number; + NFd?: number; + /** * The number of goroutines that currently exist. This information is only returned if debug-mode is enabled. */ - 'NGoroutines'?: number; + NGoroutines?: number; + /** * Current system-time in [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds. */ - 'SystemTime'?: string; + SystemTime?: string; + /** * The logging driver to use as a default for new containers. */ - 'LoggingDriver'?: string; + LoggingDriver?: string; + /** * The driver to use for managing cgroups. */ - 'CgroupDriver'?: SystemInfoCgroupDriverEnum; + CgroupDriver?: SystemInfoCgroupDriverEnum; + /** * The version of the cgroup. */ - 'CgroupVersion'?: SystemInfoCgroupVersionEnum; + CgroupVersion?: SystemInfoCgroupVersionEnum; + /** * Number of event listeners subscribed. */ - 'NEventsListener'?: number; + NEventsListener?: number; + /** - * Kernel version of the host. On Linux, this information obtained from `uname`. On Windows this information is queried from the HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Windows NT\\\\CurrentVersion\\\\ registry value, for example _\"10.0 14393 (14393.1198.amd64fre.rs1_release_sec.170427-1353)\"_. + * Kernel version of the host. On Linux, this information obtained from `uname`. On Windows this information is queried from the <kbd>HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Windows NT\\\\CurrentVersion\\\\</kbd> registry value, for example _\"10.0 14393 (14393.1198.amd64fre.rs1_release_sec.170427-1353)\"_. */ - 'KernelVersion'?: string; + KernelVersion?: string; + /** - * Name of the host\'s operating system, for example: \"Ubuntu 24.04 LTS\" or \"Windows Server 2016 Datacenter\" + * Name of the host\'s operating system, for example: \"Ubuntu 24.04 LTS\" or \"Windows Server 2016 Datacenter\" */ - 'OperatingSystem'?: string; + OperatingSystem?: string; + /** - * Version of the host\'s operating system


> **Note**: The information returned in this field, including its > very existence, and the formatting of values, should not be considered > stable, and may change without notice. + * Version of the host\'s operating system <p><br /></p> > **Note**: The information returned in this field, including its > very existence, and the formatting of values, should not be considered > stable, and may change without notice. */ - 'OSVersion'?: string; + OSVersion?: string; + /** - * Generic type of the operating system of the host, as returned by the Go runtime (`GOOS`). Currently returned values are \"linux\" and \"windows\". A full list of possible values can be found in the [Go documentation](https://go.dev/doc/install/source#environment). + * Generic type of the operating system of the host, as returned by the Go runtime (`GOOS`). Currently returned values are \"linux\" and \"windows\". A full list of possible values can be found in the [Go documentation](https://go.dev/doc/install/source#environment). */ - 'OSType'?: string; + OSType?: string; + /** - * Hardware architecture of the host, as returned by the Go runtime (`GOARCH`). A full list of possible values can be found in the [Go documentation](https://go.dev/doc/install/source#environment). + * Hardware architecture of the host, as returned by the Go runtime (`GOARCH`). A full list of possible values can be found in the [Go documentation](https://go.dev/doc/install/source#environment). */ - 'Architecture'?: string; + Architecture?: string; + /** * The number of logical CPUs usable by the daemon. The number of available CPUs is checked by querying the operating system when the daemon starts. Changes to operating system CPU allocation after the daemon is started are not reflected. */ - 'NCPU'?: number; + NCPU?: number; + /** * Total amount of physical memory available on the host, in bytes. */ - 'MemTotal'?: number; + MemTotal?: number; + /** * Address / URL of the index server that is used for image search, and as a default for user authentication for Docker Hub and Docker Cloud. */ - 'IndexServerAddress'?: string; - 'RegistryConfig'?: RegistryServiceConfig | null; + IndexServerAddress?: string; + + RegistryConfig?: RegistryServiceConfig | null; + /** - * User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, `GPU=UUID1`). + * User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, `GPU=UUID1`). */ - 'GenericResources'?: Array; + GenericResources?: Array; + /** - * HTTP-proxy configured for the daemon. This value is obtained from the [`HTTP_PROXY`](https://www.gnu.org/software/wget/manual/html_node/Proxies.html) environment variable. Credentials ([user info component](https://tools.ietf.org/html/rfc3986#section-3.2.1)) in the proxy URL are masked in the API response. Containers do not automatically inherit this configuration. + * HTTP-proxy configured for the daemon. This value is obtained from the [`HTTP_PROXY`](https://www.gnu.org/software/wget/manual/html_node/Proxies.html) environment variable. Credentials ([user info component](https://tools.ietf.org/html/rfc3986#section-3.2.1)) in the proxy URL are masked in the API response. Containers do not automatically inherit this configuration. */ - 'HttpProxy'?: string; + HttpProxy?: string; + /** - * HTTPS-proxy configured for the daemon. This value is obtained from the [`HTTPS_PROXY`](https://www.gnu.org/software/wget/manual/html_node/Proxies.html) environment variable. Credentials ([user info component](https://tools.ietf.org/html/rfc3986#section-3.2.1)) in the proxy URL are masked in the API response. Containers do not automatically inherit this configuration. + * HTTPS-proxy configured for the daemon. This value is obtained from the [`HTTPS_PROXY`](https://www.gnu.org/software/wget/manual/html_node/Proxies.html) environment variable. Credentials ([user info component](https://tools.ietf.org/html/rfc3986#section-3.2.1)) in the proxy URL are masked in the API response. Containers do not automatically inherit this configuration. */ - 'HttpsProxy'?: string; + HttpsProxy?: string; + /** - * Comma-separated list of domain extensions for which no proxy should be used. This value is obtained from the [`NO_PROXY`](https://www.gnu.org/software/wget/manual/html_node/Proxies.html) environment variable. Containers do not automatically inherit this configuration. + * Comma-separated list of domain extensions for which no proxy should be used. This value is obtained from the [`NO_PROXY`](https://www.gnu.org/software/wget/manual/html_node/Proxies.html) environment variable. Containers do not automatically inherit this configuration. */ - 'NoProxy'?: string; + NoProxy?: string; + /** * Hostname of the host. */ - 'Name'?: string; + Name?: string; + /** - * User-defined labels (key/value metadata) as set on the daemon.


> **Note**: When part of a Swarm, nodes can both have _daemon_ labels, > set through the daemon configuration, and _node_ labels, set from a > manager node in the Swarm. Node labels are not included in this > field. Node labels can be retrieved using the `/nodes/(id)` endpoint > on a manager node in the Swarm. + * User-defined labels (key/value metadata) as set on the daemon. <p><br /></p> > **Note**: When part of a Swarm, nodes can both have _daemon_ labels, > set through the daemon configuration, and _node_ labels, set from a > manager node in the Swarm. Node labels are not included in this > field. Node labels can be retrieved using the `/nodes/(id)` endpoint > on a manager node in the Swarm. */ - 'Labels'?: Array; + Labels?: Array; + /** * Indicates if experimental features are enabled on the daemon. */ - 'ExperimentalBuild'?: boolean; + ExperimentalBuild?: boolean; + /** * Version string of the daemon. */ - 'ServerVersion'?: string; + ServerVersion?: string; + /** - * List of [OCI compliant](https://github.com/opencontainers/runtime-spec) runtimes configured on the daemon. Keys hold the \"name\" used to reference the runtime. The Docker daemon relies on an OCI compliant runtime (invoked via the `containerd` daemon) as its interface to the Linux kernel namespaces, cgroups, and SELinux. The default runtime is `runc`, and automatically configured. Additional runtimes can be configured by the user and will be listed here. + * List of [OCI compliant](https://github.com/opencontainers/runtime-spec) runtimes configured on the daemon. Keys hold the \"name\" used to reference the runtime. The Docker daemon relies on an OCI compliant runtime (invoked via the `containerd` daemon) as its interface to the Linux kernel namespaces, cgroups, and SELinux. The default runtime is `runc`, and automatically configured. Additional runtimes can be configured by the user and will be listed here. */ - 'Runtimes'?: { [key: string]: Runtime }; + Runtimes?: { [key: string]: Runtime }; + /** * Name of the default OCI runtime that is used when starting containers. The default can be overridden per-container at create time. */ - 'DefaultRuntime'?: string; - 'Swarm'?: SwarmInfo; + DefaultRuntime?: string; + + Swarm?: SwarmInfo; + /** * Indicates if live restore is enabled. If enabled, containers are kept running when the daemon is shutdown or upon daemon start if running containers are detected. */ - 'LiveRestoreEnabled'?: boolean; + LiveRestoreEnabled?: boolean; + /** - * Represents the isolation technology to use as a default for containers. The supported values are platform-specific. If no isolation value is specified on daemon start, on Windows client, the default is `hyperv`, and on Windows server, the default is `process`. This option is currently not used on other platforms. + * Represents the isolation technology to use as a default for containers. The supported values are platform-specific. If no isolation value is specified on daemon start, on Windows client, the default is `hyperv`, and on Windows server, the default is `process`. This option is currently not used on other platforms. */ - 'Isolation'?: SystemInfoIsolationEnum; + Isolation?: SystemInfoIsolationEnum; + /** - * Name and, optional, path of the `docker-init` binary. If the path is omitted, the daemon searches the host\'s `$PATH` for the binary and uses the first result. + * Name and, optional, path of the `docker-init` binary. If the path is omitted, the daemon searches the host\'s `$PATH` for the binary and uses the first result. */ - 'InitBinary'?: string; - 'ContainerdCommit'?: Commit; - 'RuncCommit'?: Commit; - 'InitCommit'?: Commit; + InitBinary?: string; + + ContainerdCommit?: Commit; + + RuncCommit?: Commit; + + InitCommit?: Commit; + /** * List of security features that are enabled on the daemon, such as apparmor, seccomp, SELinux, user-namespaces (userns), rootless and no-new-privileges. Additional configuration options for each security feature may be present, and are included as a comma-separated list of key/value pairs. */ - 'SecurityOptions'?: Array; + SecurityOptions?: Array; + /** * Reports a summary of the product license on the daemon. If a commercial license has been applied to the daemon, information such as number of nodes, and expiration are included. */ - 'ProductLicense'?: string; + ProductLicense?: string; + /** - * List of custom default address pools for local networks, which can be specified in the daemon.json file or dockerd option. Example: a Base \"10.10.0.0/16\" with Size 24 will define the set of 256 10.10.[0-255].0/24 address pools. + * List of custom default address pools for local networks, which can be specified in the daemon.json file or dockerd option. Example: a Base \"10.10.0.0/16\" with Size 24 will define the set of 256 10.10.[0-255].0/24 address pools. */ - 'DefaultAddressPools'?: Array; - 'FirewallBackend'?: FirewallInfo | null; + DefaultAddressPools?: Array; + + FirewallBackend?: FirewallInfo | null; + /** * List of devices discovered by device drivers. Each device includes information about its source driver, kind, name, and additional driver-specific attributes. */ - 'DiscoveredDevices'?: Array; + DiscoveredDevices?: Array; + /** * List of warnings / informational messages about missing features, or issues related to the daemon configuration. These messages can be printed by the client as information to the user. */ - 'Warnings'?: Array; + Warnings?: Array; + /** * List of directories where (Container Device Interface) CDI specifications are located. These specifications define vendor-specific modifications to an OCI runtime specification for a container being created. An empty list indicates that CDI device injection is disabled. Note that since using CDI device injection requires the daemon to have experimental enabled. For non-experimental daemons an empty list will always be returned. */ - 'CDISpecDirs'?: Array; - 'Containerd'?: ContainerdInfo | null; -} + CDISpecDirs?: Array; -export enum SystemInfoCgroupDriverEnum { - Cgroupfs = 'cgroupfs', - Systemd = 'systemd', - None = 'none', -} -export enum SystemInfoCgroupVersionEnum { - _1 = '1', - _2 = '2', -} -export enum SystemInfoIsolationEnum { - Default = 'default', - Hyperv = 'hyperv', - Process = 'process', - Empty = '', + Containerd?: ContainerdInfo | null; } + +export type SystemInfoCgroupDriverEnum = 'cgroupfs' | 'systemd' | 'none'; +export type SystemInfoCgroupVersionEnum = '1' | '2'; +export type SystemInfoIsolationEnum = 'default' | 'hyperv' | 'process' | ''; diff --git a/src/models/SystemInfoDefaultAddressPoolsInner.ts b/src/models/SystemInfoDefaultAddressPoolsInner.ts index f811a31..fb3ce9e 100644 --- a/src/models/SystemInfoDefaultAddressPoolsInner.ts +++ b/src/models/SystemInfoDefaultAddressPoolsInner.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SystemInfoDefaultAddressPoolsInner { +export interface SystemInfoDefaultAddressPoolsInner { /** * The network address in CIDR format */ - 'Base'?: string; + Base?: string; + /** * The network pool size */ - 'Size'?: number; + Size?: number; } diff --git a/src/models/SystemVersion.ts b/src/models/SystemVersion.ts index 5c694c7..ed7bffa 100644 --- a/src/models/SystemVersion.ts +++ b/src/models/SystemVersion.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { SystemVersionComponentsInner } from '../models/SystemVersionComponentsInner.js'; @@ -16,50 +24,61 @@ import { SystemVersionPlatform } from '../models/SystemVersionPlatform.js'; /** * Response of Engine API: GET \"/version\" */ -export class SystemVersion { - 'Platform'?: SystemVersionPlatform; +export interface SystemVersion { + Platform?: SystemVersionPlatform; + /** * Information about system components */ - 'Components'?: Array; + Components?: Array; + /** * The version of the daemon */ - 'Version'?: string; + Version?: string; + /** * The default (and highest) API version that is supported by the daemon */ - 'ApiVersion'?: string; + ApiVersion?: string; + /** * The minimum API version that is supported by the daemon */ - 'MinAPIVersion'?: string; + MinAPIVersion?: string; + /** * The Git commit of the source code that was used to build the daemon */ - 'GitCommit'?: string; + GitCommit?: string; + /** * The version Go used to compile the daemon, and the version of the Go runtime in use. */ - 'GoVersion'?: string; + GoVersion?: string; + /** - * The operating system that the daemon is running on (\"linux\" or \"windows\") + * The operating system that the daemon is running on (\"linux\" or \"windows\") */ - 'Os'?: string; + Os?: string; + /** * The architecture that the daemon is running on */ - 'Arch'?: string; + Arch?: string; + /** - * The kernel version (`uname -r`) that the daemon is running on. This field is omitted when empty. + * The kernel version (`uname -r`) that the daemon is running on. This field is omitted when empty. */ - 'KernelVersion'?: string; + KernelVersion?: string; + /** * Indicates if the daemon is started with experimental features enabled. This field is omitted when empty / false. */ - 'Experimental'?: boolean; + Experimental?: boolean; + /** * The date and time that the daemon was compiled. */ - 'BuildTime'?: string; + BuildTime?: string; } diff --git a/src/models/SystemVersionComponentsInner.ts b/src/models/SystemVersionComponentsInner.ts index 1444b03..27358cd 100644 --- a/src/models/SystemVersionComponentsInner.ts +++ b/src/models/SystemVersionComponentsInner.ts @@ -1,26 +1,36 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SystemVersionComponentsInner { +export interface SystemVersionComponentsInner { /** * Name of the component */ - 'Name': string; + Name: string; + /** * Version of the component */ - 'Version': string; + Version: string; + /** * Key/value pairs of strings with additional information about the component. These values are intended for informational purposes only, and their content is not defined, and not part of the API specification. These messages can be printed by the client as information to the user. */ - 'Details'?: any; + Details?: any | null; } diff --git a/src/models/SystemVersionPlatform.ts b/src/models/SystemVersionPlatform.ts index 8adb769..b55a7f4 100644 --- a/src/models/SystemVersionPlatform.ts +++ b/src/models/SystemVersionPlatform.ts @@ -1,15 +1,23 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class SystemVersionPlatform { - 'Name': string; +export interface SystemVersionPlatform { + Name: string; } diff --git a/src/models/TLSInfo.ts b/src/models/TLSInfo.ts index 361b8a5..c2cdf35 100644 --- a/src/models/TLSInfo.ts +++ b/src/models/TLSInfo.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Information about the issuer of leaf TLS certificates and the trusted root CA certificate. */ -export class TLSInfo { +export interface TLSInfo { /** * The root CA certificate(s) that are used to validate leaf TLS certificates. */ - 'TrustRoot'?: string; + TrustRoot?: string; + /** * The base64-url-safe-encoded raw subject bytes of the issuer. */ - 'CertIssuerSubject'?: string; + CertIssuerSubject?: string; + /** * The base64-url-safe-encoded raw public key bytes of the issuer. */ - 'CertIssuerPublicKey'?: string; + CertIssuerPublicKey?: string; } diff --git a/src/models/Task.ts b/src/models/Task.ts index a642950..13e2bbd 100644 --- a/src/models/Task.ts +++ b/src/models/Task.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { GenericResourcesInner } from '../models/GenericResourcesInner.js'; @@ -16,37 +24,50 @@ import { TaskSpec } from '../models/TaskSpec.js'; import { TaskState } from '../models/TaskState.js'; import { TaskStatus } from '../models/TaskStatus.js'; -export class Task { +export interface Task { /** * The ID of the task. */ - 'ID'?: string; - 'Version'?: ObjectVersion; - 'CreatedAt'?: string; - 'UpdatedAt'?: string; + ID?: string; + + Version?: ObjectVersion; + + CreatedAt?: string; + + UpdatedAt?: string; + /** * Name of the task. */ - 'Name'?: string; + Name?: string; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'Spec'?: TaskSpec; + Labels?: { [key: string]: string }; + + Spec?: TaskSpec; + /** * The ID of the service this task is part of. */ - 'ServiceID'?: string; - 'Slot'?: number; + ServiceID?: string; + + Slot?: number; + /** * The ID of the node that this task is on. */ - 'NodeID'?: string; + NodeID?: string; + /** - * User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, `GPU=UUID1`). + * User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, `GPU=UUID1`). */ - 'AssignedGenericResources'?: Array; - 'Status'?: TaskStatus; - 'DesiredState'?: TaskState; - 'JobIteration'?: ObjectVersion; + AssignedGenericResources?: Array; + + Status?: TaskStatus; + + DesiredState?: TaskState; + + JobIteration?: ObjectVersion; } diff --git a/src/models/TaskSpec.ts b/src/models/TaskSpec.ts index 26b67cf..0591d21 100644 --- a/src/models/TaskSpec.ts +++ b/src/models/TaskSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { NetworkAttachmentConfig } from '../models/NetworkAttachmentConfig.js'; @@ -22,24 +30,33 @@ import { TaskSpecRestartPolicy } from '../models/TaskSpecRestartPolicy.js'; /** * User modifiable task configuration. */ -export class TaskSpec { - 'PluginSpec'?: TaskSpecPluginSpec; - 'ContainerSpec'?: TaskSpecContainerSpec; - 'NetworkAttachmentSpec'?: TaskSpecNetworkAttachmentSpec; - 'Resources'?: TaskSpecResources; - 'RestartPolicy'?: TaskSpecRestartPolicy; - 'Placement'?: TaskSpecPlacement; +export interface TaskSpec { + PluginSpec?: TaskSpecPluginSpec; + + ContainerSpec?: TaskSpecContainerSpec; + + NetworkAttachmentSpec?: TaskSpecNetworkAttachmentSpec; + + Resources?: TaskSpecResources; + + RestartPolicy?: TaskSpecRestartPolicy; + + Placement?: TaskSpecPlacement; + /** * A counter that triggers an update even if no relevant parameters have been changed. */ - 'ForceUpdate'?: number; + ForceUpdate?: number; + /** * Runtime is the type of runtime specified for the task executor. */ - 'Runtime'?: string; + Runtime?: string; + /** * Specifies which networks the service should attach to. */ - 'Networks'?: Array; - 'LogDriver'?: TaskSpecLogDriver; + Networks?: Array; + + LogDriver?: TaskSpecLogDriver; } diff --git a/src/models/TaskSpecContainerSpec.ts b/src/models/TaskSpecContainerSpec.ts index f1d5ec1..2d4e1ce 100644 --- a/src/models/TaskSpecContainerSpec.ts +++ b/src/models/TaskSpecContainerSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { HealthConfig } from '../models/HealthConfig.js'; @@ -21,115 +29,141 @@ import { TaskSpecContainerSpecSecretsInner } from '../models/TaskSpecContainerSp /** * Container spec for the service.


> **Note**: ContainerSpec, NetworkAttachmentSpec, and PluginSpec are > mutually exclusive. PluginSpec is only used when the Runtime field > is set to `plugin`. NetworkAttachmentSpec is used when the Runtime > field is set to `attachment`. */ -export class TaskSpecContainerSpec { +export interface TaskSpecContainerSpec { /** * The image name to use for the container */ - 'Image'?: string; + Image?: string; + /** * User-defined key/value data. */ - 'Labels'?: { [key: string]: string }; + Labels?: { [key: string]: string }; + /** * The command to be run in the image. */ - 'Command'?: Array; + Command?: Array; + /** * Arguments to the command. */ - 'Args'?: Array; + Args?: Array; + /** * The hostname to use for the container, as a valid [RFC 1123](https://tools.ietf.org/html/rfc1123) hostname. */ - 'Hostname'?: string; + Hostname?: string; + /** - * A list of environment variables in the form `VAR=value`. + * A list of environment variables in the form `VAR=value`. */ - 'Env'?: Array; + Env?: Array; + /** * The working directory for commands to run in. */ - 'Dir'?: string; + Dir?: string; + /** * The user inside the container. */ - 'User'?: string; + User?: string; + /** * A list of additional groups that the container process will run as. */ - 'Groups'?: Array; - 'Privileges'?: TaskSpecContainerSpecPrivileges; + Groups?: Array; + + Privileges?: TaskSpecContainerSpecPrivileges; + /** * Whether a pseudo-TTY should be allocated. */ - 'TTY'?: boolean; + TTY?: boolean; + /** - * Open `stdin` + * Open `stdin` */ - 'OpenStdin'?: boolean; + OpenStdin?: boolean; + /** - * Mount the container\'s root filesystem as read only. + * Mount the container\'s root filesystem as read only. */ - 'ReadOnly'?: boolean; + ReadOnly?: boolean; + /** * Specification for mounts to be added to containers created as part of the service. */ - 'Mounts'?: Array; + Mounts?: Array; + /** * Signal to stop the container. */ - 'StopSignal'?: string; + StopSignal?: string; + /** * Amount of time to wait for the container to terminate before forcefully killing it. */ - 'StopGracePeriod'?: number; - 'HealthCheck'?: HealthConfig; + StopGracePeriod?: number; + + HealthCheck?: HealthConfig; + /** - * A list of hostname/IP mappings to add to the container\'s `hosts` file. The format of extra hosts is specified in the [hosts(5)](http://man7.org/linux/man-pages/man5/hosts.5.html) man page: IP_address canonical_hostname [aliases...] + * A list of hostname/IP mappings to add to the container\'s `hosts` file. The format of extra hosts is specified in the [hosts(5)](http://man7.org/linux/man-pages/man5/hosts.5.html) man page: IP_address canonical_hostname [aliases...] */ - 'Hosts'?: Array; - 'DNSConfig'?: TaskSpecContainerSpecDNSConfig; + Hosts?: Array; + + DNSConfig?: TaskSpecContainerSpecDNSConfig; + /** * Secrets contains references to zero or more secrets that will be exposed to the service. */ - 'Secrets'?: Array; + Secrets?: Array; + /** * An integer value containing the score given to the container in order to tune OOM killer preferences. */ - 'OomScoreAdj'?: number; + OomScoreAdj?: number; + /** * Configs contains references to zero or more configs that will be exposed to the service. */ - 'Configs'?: Array; + Configs?: Array; + /** * Isolation technology of the containers running the service. (Windows only) */ - 'Isolation'?: TaskSpecContainerSpecIsolationEnum; + Isolation?: TaskSpecContainerSpecIsolationEnum; + /** * Run an init inside the container that forwards signals and reaps processes. This field is omitted if empty, and the default (as configured on the daemon) is used. */ - 'Init'?: boolean | null; + Init?: boolean | null; + /** - * Set kernel namedspaced parameters (sysctls) in the container. The Sysctls option on services accepts the same sysctls as the are supported on containers. Note that while the same sysctls are supported, no guarantees or checks are made about their suitability for a clustered environment, and it\'s up to the user to determine whether a given sysctl will work properly in a Service. + * Set kernel namedspaced parameters (sysctls) in the container. The Sysctls option on services accepts the same sysctls as the are supported on containers. Note that while the same sysctls are supported, no guarantees or checks are made about their suitability for a clustered environment, and it\'s up to the user to determine whether a given sysctl will work properly in a Service. */ - 'Sysctls'?: { [key: string]: string }; + Sysctls?: { [key: string]: string }; + /** * A list of kernel capabilities to add to the default set for the container. */ - 'CapabilityAdd'?: Array; + CapabilityAdd?: Array; + /** * A list of kernel capabilities to drop from the default set for the container. */ - 'CapabilityDrop'?: Array; + CapabilityDrop?: Array; + /** - * A list of resource limits to set in the container. For example: `{\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048}`\" + * A list of resource limits to set in the container. For example: `{\"Name\": \"nofile\", \"Soft\": 1024, \"Hard\": 2048}`\" */ - 'Ulimits'?: Array; + Ulimits?: Array; } -export enum TaskSpecContainerSpecIsolationEnum { - Default = 'default', - Process = 'process', - Hyperv = 'hyperv', - Empty = '', -} +export type TaskSpecContainerSpecIsolationEnum = + | 'default' + | 'process' + | 'hyperv' + | ''; diff --git a/src/models/TaskSpecContainerSpecConfigsInner.ts b/src/models/TaskSpecContainerSpecConfigsInner.ts index 5d28e28..d3f20f7 100644 --- a/src/models/TaskSpecContainerSpecConfigsInner.ts +++ b/src/models/TaskSpecContainerSpecConfigsInner.ts @@ -1,29 +1,40 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { TaskSpecContainerSpecConfigsInnerFile } from '../models/TaskSpecContainerSpecConfigsInnerFile.js'; -export class TaskSpecContainerSpecConfigsInner { - 'File'?: TaskSpecContainerSpecConfigsInnerFile; +export interface TaskSpecContainerSpecConfigsInner { + File?: TaskSpecContainerSpecConfigsInnerFile; + /** - * Runtime represents a target that is not mounted into the container but is used by the task


> **Note**: `Configs.File` and `Configs.Runtime` are mutually > exclusive + * Runtime represents a target that is not mounted into the container but is used by the task <p><br /><p> > **Note**: `Configs.File` and `Configs.Runtime` are mutually > exclusive */ - 'Runtime'?: any; + Runtime?: any; + /** - * ConfigID represents the ID of the specific config that we\'re referencing. + * ConfigID represents the ID of the specific config that we\'re referencing. */ - 'ConfigID'?: string; + ConfigID?: string; + /** * ConfigName is the name of the config that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID. */ - 'ConfigName'?: string; + ConfigName?: string; } diff --git a/src/models/TaskSpecContainerSpecConfigsInnerFile.ts b/src/models/TaskSpecContainerSpecConfigsInnerFile.ts index df403d7..8514f3e 100644 --- a/src/models/TaskSpecContainerSpecConfigsInnerFile.ts +++ b/src/models/TaskSpecContainerSpecConfigsInnerFile.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * File represents a specific target that is backed by a file.


> **Note**: `Configs.File` and `Configs.Runtime` are mutually exclusive */ -export class TaskSpecContainerSpecConfigsInnerFile { +export interface TaskSpecContainerSpecConfigsInnerFile { /** * Name represents the final filename in the filesystem. */ - 'Name'?: string; + Name?: string; + /** * UID represents the file UID. */ - 'UID'?: string; + UID?: string; + /** * GID represents the file GID. */ - 'GID'?: string; + GID?: string; + /** * Mode represents the FileMode of the file. */ - 'Mode'?: number; + Mode?: number; } diff --git a/src/models/TaskSpecContainerSpecDNSConfig.ts b/src/models/TaskSpecContainerSpecDNSConfig.ts index b1bb4c9..00f3482 100644 --- a/src/models/TaskSpecContainerSpecDNSConfig.ts +++ b/src/models/TaskSpecContainerSpecDNSConfig.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Specification for DNS related configurations in resolver configuration file (`resolv.conf`). */ -export class TaskSpecContainerSpecDNSConfig { +export interface TaskSpecContainerSpecDNSConfig { /** * The IP addresses of the name servers. */ - 'Nameservers'?: Array; + Nameservers?: Array; + /** * A search list for host-name lookup. */ - 'Search'?: Array; + Search?: Array; + /** - * A list of internal resolver variables to be modified (e.g., `debug`, `ndots:3`, etc.). + * A list of internal resolver variables to be modified (e.g., `debug`, `ndots:3`, etc.). */ - 'Options'?: Array; + Options?: Array; } diff --git a/src/models/TaskSpecContainerSpecPrivileges.ts b/src/models/TaskSpecContainerSpecPrivileges.ts index c55a7bc..2df5fda 100644 --- a/src/models/TaskSpecContainerSpecPrivileges.ts +++ b/src/models/TaskSpecContainerSpecPrivileges.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { TaskSpecContainerSpecPrivilegesAppArmor } from '../models/TaskSpecContainerSpecPrivilegesAppArmor.js'; @@ -18,13 +26,17 @@ import { TaskSpecContainerSpecPrivilegesSeccomp } from '../models/TaskSpecContai /** * Security options for the container */ -export class TaskSpecContainerSpecPrivileges { - 'CredentialSpec'?: TaskSpecContainerSpecPrivilegesCredentialSpec; - 'SELinuxContext'?: TaskSpecContainerSpecPrivilegesSELinuxContext; - 'Seccomp'?: TaskSpecContainerSpecPrivilegesSeccomp; - 'AppArmor'?: TaskSpecContainerSpecPrivilegesAppArmor; +export interface TaskSpecContainerSpecPrivileges { + CredentialSpec?: TaskSpecContainerSpecPrivilegesCredentialSpec; + + SELinuxContext?: TaskSpecContainerSpecPrivilegesSELinuxContext; + + Seccomp?: TaskSpecContainerSpecPrivilegesSeccomp; + + AppArmor?: TaskSpecContainerSpecPrivilegesAppArmor; + /** * Configuration of the no_new_privs bit in the container */ - 'NoNewPrivileges'?: boolean; + NoNewPrivileges?: boolean; } diff --git a/src/models/TaskSpecContainerSpecPrivilegesAppArmor.ts b/src/models/TaskSpecContainerSpecPrivilegesAppArmor.ts index 2e534e5..73e104b 100644 --- a/src/models/TaskSpecContainerSpecPrivilegesAppArmor.ts +++ b/src/models/TaskSpecContainerSpecPrivilegesAppArmor.ts @@ -1,23 +1,30 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Options for configuring AppArmor on the container */ -export class TaskSpecContainerSpecPrivilegesAppArmor { - 'Mode'?: TaskSpecContainerSpecPrivilegesAppArmorModeEnum; +export interface TaskSpecContainerSpecPrivilegesAppArmor { + Mode?: TaskSpecContainerSpecPrivilegesAppArmorModeEnum; } -export enum TaskSpecContainerSpecPrivilegesAppArmorModeEnum { - Default = 'default', - Disabled = 'disabled', -} +export type TaskSpecContainerSpecPrivilegesAppArmorModeEnum = + | 'default' + | 'disabled'; diff --git a/src/models/TaskSpecContainerSpecPrivilegesCredentialSpec.ts b/src/models/TaskSpecContainerSpecPrivilegesCredentialSpec.ts index c5d97d9..72579e7 100644 --- a/src/models/TaskSpecContainerSpecPrivilegesCredentialSpec.ts +++ b/src/models/TaskSpecContainerSpecPrivilegesCredentialSpec.ts @@ -1,29 +1,39 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * CredentialSpec for managed service account (Windows only) */ -export class TaskSpecContainerSpecPrivilegesCredentialSpec { +export interface TaskSpecContainerSpecPrivilegesCredentialSpec { /** - * Load credential spec from a Swarm Config with the given ID. The specified config must also be present in the Configs field with the Runtime property set.


> **Note**: `CredentialSpec.File`, `CredentialSpec.Registry`, > and `CredentialSpec.Config` are mutually exclusive. + * Load credential spec from a Swarm Config with the given ID. The specified config must also be present in the Configs field with the Runtime property set. <p><br /></p> > **Note**: `CredentialSpec.File`, `CredentialSpec.Registry`, > and `CredentialSpec.Config` are mutually exclusive. */ - 'Config'?: string; + Config?: string; + /** - * Load credential spec from this file. The file is read by the daemon, and must be present in the `CredentialSpecs` subdirectory in the docker data directory, which defaults to `C:\\ProgramData\\Docker\\` on Windows. For example, specifying `spec.json` loads `C:\\ProgramData\\Docker\\CredentialSpecs\\spec.json`.


> **Note**: `CredentialSpec.File`, `CredentialSpec.Registry`, > and `CredentialSpec.Config` are mutually exclusive. + * Load credential spec from this file. The file is read by the daemon, and must be present in the `CredentialSpecs` subdirectory in the docker data directory, which defaults to `C:\\ProgramData\\Docker\\` on Windows. For example, specifying `spec.json` loads `C:\\ProgramData\\Docker\\CredentialSpecs\\spec.json`. <p><br /></p> > **Note**: `CredentialSpec.File`, `CredentialSpec.Registry`, > and `CredentialSpec.Config` are mutually exclusive. */ - 'File'?: string; + File?: string; + /** - * Load credential spec from this value in the Windows registry. The specified registry value must be located in: `HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Virtualization\\Containers\\CredentialSpecs`


> **Note**: `CredentialSpec.File`, `CredentialSpec.Registry`, > and `CredentialSpec.Config` are mutually exclusive. + * Load credential spec from this value in the Windows registry. The specified registry value must be located in: `HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Virtualization\\Containers\\CredentialSpecs` <p><br /></p> > **Note**: `CredentialSpec.File`, `CredentialSpec.Registry`, > and `CredentialSpec.Config` are mutually exclusive. */ - 'Registry'?: string; + Registry?: string; } diff --git a/src/models/TaskSpecContainerSpecPrivilegesSELinuxContext.ts b/src/models/TaskSpecContainerSpecPrivilegesSELinuxContext.ts index d7a33bd..9acab21 100644 --- a/src/models/TaskSpecContainerSpecPrivilegesSELinuxContext.ts +++ b/src/models/TaskSpecContainerSpecPrivilegesSELinuxContext.ts @@ -1,37 +1,49 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * SELinux labels of the container */ -export class TaskSpecContainerSpecPrivilegesSELinuxContext { +export interface TaskSpecContainerSpecPrivilegesSELinuxContext { /** * Disable SELinux */ - 'Disable'?: boolean; + Disable?: boolean; + /** * SELinux user label */ - 'User'?: string; + User?: string; + /** * SELinux role label */ - 'Role'?: string; + Role?: string; + /** * SELinux type label */ - 'Type'?: string; + Type?: string; + /** * SELinux level label */ - 'Level'?: string; + Level?: string; } diff --git a/src/models/TaskSpecContainerSpecPrivilegesSeccomp.ts b/src/models/TaskSpecContainerSpecPrivilegesSeccomp.ts index 35355ee..fac3f8b 100644 --- a/src/models/TaskSpecContainerSpecPrivilegesSeccomp.ts +++ b/src/models/TaskSpecContainerSpecPrivilegesSeccomp.ts @@ -1,28 +1,36 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Options for configuring seccomp on the container */ -export class TaskSpecContainerSpecPrivilegesSeccomp { - 'Mode'?: TaskSpecContainerSpecPrivilegesSeccompModeEnum; +export interface TaskSpecContainerSpecPrivilegesSeccomp { + Mode?: TaskSpecContainerSpecPrivilegesSeccompModeEnum; + /** * The custom seccomp profile as a json object */ - 'Profile'?: string; + Profile?: string; } -export enum TaskSpecContainerSpecPrivilegesSeccompModeEnum { - Default = 'default', - Unconfined = 'unconfined', - Custom = 'custom', -} +export type TaskSpecContainerSpecPrivilegesSeccompModeEnum = + | 'default' + | 'unconfined' + | 'custom'; diff --git a/src/models/TaskSpecContainerSpecSecretsInner.ts b/src/models/TaskSpecContainerSpecSecretsInner.ts index ec2a780..17ec5de 100644 --- a/src/models/TaskSpecContainerSpecSecretsInner.ts +++ b/src/models/TaskSpecContainerSpecSecretsInner.ts @@ -1,25 +1,35 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { TaskSpecContainerSpecSecretsInnerFile } from '../models/TaskSpecContainerSpecSecretsInnerFile.js'; -export class TaskSpecContainerSpecSecretsInner { - 'File'?: TaskSpecContainerSpecSecretsInnerFile; +export interface TaskSpecContainerSpecSecretsInner { + File?: TaskSpecContainerSpecSecretsInnerFile; + /** - * SecretID represents the ID of the specific secret that we\'re referencing. + * SecretID represents the ID of the specific secret that we\'re referencing. */ - 'SecretID'?: string; + SecretID?: string; + /** * SecretName is the name of the secret that this references, but this is just provided for lookup/display purposes. The secret in the reference will be identified by its ID. */ - 'SecretName'?: string; + SecretName?: string; } diff --git a/src/models/TaskSpecContainerSpecSecretsInnerFile.ts b/src/models/TaskSpecContainerSpecSecretsInnerFile.ts index 49354b8..cbd33aa 100644 --- a/src/models/TaskSpecContainerSpecSecretsInnerFile.ts +++ b/src/models/TaskSpecContainerSpecSecretsInnerFile.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * File represents a specific target that is backed by a file. */ -export class TaskSpecContainerSpecSecretsInnerFile { +export interface TaskSpecContainerSpecSecretsInnerFile { /** * Name represents the final filename in the filesystem. */ - 'Name'?: string; + Name?: string; + /** * UID represents the file UID. */ - 'UID'?: string; + UID?: string; + /** * GID represents the file GID. */ - 'GID'?: string; + GID?: string; + /** * Mode represents the FileMode of the file. */ - 'Mode'?: number; + Mode?: number; } diff --git a/src/models/TaskSpecLogDriver.ts b/src/models/TaskSpecLogDriver.ts index 00caf0a..59b9d97 100644 --- a/src/models/TaskSpecLogDriver.ts +++ b/src/models/TaskSpecLogDriver.ts @@ -1,19 +1,28 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Specifies the log driver to use for tasks created from this spec. If not present, the default one for the swarm will be used, finally falling back to the engine default if not specified. */ -export class TaskSpecLogDriver { - 'Name'?: string; - 'Options'?: { [key: string]: string }; +export interface TaskSpecLogDriver { + Name?: string; + + Options?: { [key: string]: string }; } diff --git a/src/models/TaskSpecNetworkAttachmentSpec.ts b/src/models/TaskSpecNetworkAttachmentSpec.ts index bc50f4a..39cdab0 100644 --- a/src/models/TaskSpecNetworkAttachmentSpec.ts +++ b/src/models/TaskSpecNetworkAttachmentSpec.ts @@ -1,21 +1,29 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Read-only spec type for non-swarm containers attached to swarm overlay networks.


> **Note**: ContainerSpec, NetworkAttachmentSpec, and PluginSpec are > mutually exclusive. PluginSpec is only used when the Runtime field > is set to `plugin`. NetworkAttachmentSpec is used when the Runtime > field is set to `attachment`. */ -export class TaskSpecNetworkAttachmentSpec { +export interface TaskSpecNetworkAttachmentSpec { /** * ID of the container represented by this task */ - 'ContainerID'?: string; + ContainerID?: string; } diff --git a/src/models/TaskSpecPlacement.ts b/src/models/TaskSpecPlacement.ts index c2b8551..a8c77df 100644 --- a/src/models/TaskSpecPlacement.ts +++ b/src/models/TaskSpecPlacement.ts @@ -1,33 +1,44 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Platform } from '../models/Platform.js'; import { TaskSpecPlacementPreferencesInner } from '../models/TaskSpecPlacementPreferencesInner.js'; -export class TaskSpecPlacement { +export interface TaskSpecPlacement { /** - * An array of constraint expressions to limit the set of nodes where a task can be scheduled. Constraint expressions can either use a _match_ (`==`) or _exclude_ (`!=`) rule. Multiple constraints find nodes that satisfy every expression (AND match). Constraints can match node or Docker Engine labels as follows: node attribute | matches | example ---------------------|--------------------------------|----------------------------------------------- `node.id` | Node ID | `node.id==2ivku8v2gvtg4` `node.hostname` | Node hostname | `node.hostname!=node-2` `node.role` | Node role (`manager`/`worker`) | `node.role==manager` `node.platform.os` | Node operating system | `node.platform.os==windows` `node.platform.arch` | Node architecture | `node.platform.arch==x86_64` `node.labels` | User-defined node labels | `node.labels.security==high` `engine.labels` | Docker Engine\'s labels | `engine.labels.operatingsystem==ubuntu-24.04` `engine.labels` apply to Docker Engine labels like operating system, drivers, etc. Swarm administrators add `node.labels` for operational purposes by using the [`node update endpoint`](#operation/NodeUpdate). + * An array of constraint expressions to limit the set of nodes where a task can be scheduled. Constraint expressions can either use a _match_ (`==`) or _exclude_ (`!=`) rule. Multiple constraints find nodes that satisfy every expression (AND match). Constraints can match node or Docker Engine labels as follows: node attribute | matches | example ---------------------|--------------------------------|----------------------------------------------- `node.id` | Node ID | `node.id==2ivku8v2gvtg4` `node.hostname` | Node hostname | `node.hostname!=node-2` `node.role` | Node role (`manager`/`worker`) | `node.role==manager` `node.platform.os` | Node operating system | `node.platform.os==windows` `node.platform.arch` | Node architecture | `node.platform.arch==x86_64` `node.labels` | User-defined node labels | `node.labels.security==high` `engine.labels` | Docker Engine\'s labels | `engine.labels.operatingsystem==ubuntu-24.04` `engine.labels` apply to Docker Engine labels like operating system, drivers, etc. Swarm administrators add `node.labels` for operational purposes by using the [`node update endpoint`](#operation/NodeUpdate). */ - 'Constraints'?: Array; + Constraints?: Array; + /** * Preferences provide a way to make the scheduler aware of factors such as topology. They are provided in order from highest to lowest precedence. */ - 'Preferences'?: Array; + Preferences?: Array; + /** * Maximum number of replicas for per node (default value is 0, which is unlimited) */ - 'MaxReplicas'?: number; + MaxReplicas?: number; + /** - * Platforms stores all the platforms that the service\'s image can run on. This field is used in the platform filter for scheduling. If empty, then the platform filter is off, meaning there are no scheduling restrictions. + * Platforms stores all the platforms that the service\'s image can run on. This field is used in the platform filter for scheduling. If empty, then the platform filter is off, meaning there are no scheduling restrictions. */ - 'Platforms'?: Array; + Platforms?: Array; } diff --git a/src/models/TaskSpecPlacementPreferencesInner.ts b/src/models/TaskSpecPlacementPreferencesInner.ts index abf293d..d22db5a 100644 --- a/src/models/TaskSpecPlacementPreferencesInner.ts +++ b/src/models/TaskSpecPlacementPreferencesInner.ts @@ -1,17 +1,25 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { TaskSpecPlacementPreferencesInnerSpread } from '../models/TaskSpecPlacementPreferencesInnerSpread.js'; -export class TaskSpecPlacementPreferencesInner { - 'Spread'?: TaskSpecPlacementPreferencesInnerSpread; +export interface TaskSpecPlacementPreferencesInner { + Spread?: TaskSpecPlacementPreferencesInnerSpread; } diff --git a/src/models/TaskSpecPlacementPreferencesInnerSpread.ts b/src/models/TaskSpecPlacementPreferencesInnerSpread.ts index d70b18a..5879e5d 100644 --- a/src/models/TaskSpecPlacementPreferencesInnerSpread.ts +++ b/src/models/TaskSpecPlacementPreferencesInnerSpread.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class TaskSpecPlacementPreferencesInnerSpread { +export interface TaskSpecPlacementPreferencesInnerSpread { /** - * label descriptor, such as `engine.labels.az`. + * label descriptor, such as `engine.labels.az`. */ - 'SpreadDescriptor'?: string; + SpreadDescriptor?: string; } diff --git a/src/models/TaskSpecPluginSpec.ts b/src/models/TaskSpecPluginSpec.ts index 2178580..b0945f2 100644 --- a/src/models/TaskSpecPluginSpec.ts +++ b/src/models/TaskSpecPluginSpec.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { PluginPrivilege } from '../models/PluginPrivilege.js'; @@ -15,18 +23,21 @@ import { PluginPrivilege } from '../models/PluginPrivilege.js'; /** * Plugin spec for the service. *(Experimental release only.)*


> **Note**: ContainerSpec, NetworkAttachmentSpec, and PluginSpec are > mutually exclusive. PluginSpec is only used when the Runtime field > is set to `plugin`. NetworkAttachmentSpec is used when the Runtime > field is set to `attachment`. */ -export class TaskSpecPluginSpec { +export interface TaskSpecPluginSpec { /** - * The name or \'alias\' to use for the plugin. + * The name or \'alias\' to use for the plugin. */ - 'Name'?: string; + Name?: string; + /** * The plugin image reference to use. */ - 'Remote'?: string; + Remote?: string; + /** * Disable the plugin once scheduled. */ - 'Disabled'?: boolean; - 'PluginPrivilege'?: Array; + Disabled?: boolean; + + PluginPrivilege?: Array; } diff --git a/src/models/TaskSpecResources.ts b/src/models/TaskSpecResources.ts index 4cc172e..12cbdca 100644 --- a/src/models/TaskSpecResources.ts +++ b/src/models/TaskSpecResources.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Limit } from '../models/Limit.js'; @@ -16,7 +24,8 @@ import { ResourceObject } from '../models/ResourceObject.js'; /** * Resource requirements which apply to each individual container created as part of the service. */ -export class TaskSpecResources { - 'Limits'?: Limit; - 'Reservations'?: ResourceObject; +export interface TaskSpecResources { + Limits?: Limit; + + Reservations?: ResourceObject; } diff --git a/src/models/TaskSpecRestartPolicy.ts b/src/models/TaskSpecRestartPolicy.ts index 5062b50..6658e38 100644 --- a/src/models/TaskSpecRestartPolicy.ts +++ b/src/models/TaskSpecRestartPolicy.ts @@ -1,39 +1,46 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Specification for the restart policy which applies to containers created as part of this service. */ -export class TaskSpecRestartPolicy { +export interface TaskSpecRestartPolicy { /** * Condition for restart. */ - 'Condition'?: TaskSpecRestartPolicyConditionEnum; + Condition?: TaskSpecRestartPolicyConditionEnum; + /** * Delay between restart attempts. */ - 'Delay'?: number; + Delay?: number; + /** * Maximum attempts to restart a given container before giving up (default value is 0, which is ignored). */ - 'MaxAttempts'?: number; + MaxAttempts?: number; + /** * Windows is the time window used to evaluate the restart policy (default value is 0, which is unbounded). */ - 'Window'?: number; + Window?: number; } -export enum TaskSpecRestartPolicyConditionEnum { - None = 'none', - OnFailure = 'on-failure', - Any = 'any', -} +export type TaskSpecRestartPolicyConditionEnum = 'none' | 'on-failure' | 'any'; diff --git a/src/models/TaskState.ts b/src/models/TaskState.ts index 28bf65a..0388713 100644 --- a/src/models/TaskState.ts +++ b/src/models/TaskState.ts @@ -1,29 +1,36 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export enum TaskState { - New = 'new', - Allocated = 'allocated', - Pending = 'pending', - Assigned = 'assigned', - Accepted = 'accepted', - Preparing = 'preparing', - Ready = 'ready', - Starting = 'starting', - Running = 'running', - Complete = 'complete', - Shutdown = 'shutdown', - Failed = 'failed', - Rejected = 'rejected', - Remove = 'remove', - Orphaned = 'orphaned', -} +export type TaskState = + | 'new' + | 'allocated' + | 'pending' + | 'assigned' + | 'accepted' + | 'preparing' + | 'ready' + | 'starting' + | 'running' + | 'complete' + | 'shutdown' + | 'failed' + | 'rejected' + | 'remove' + | 'orphaned'; diff --git a/src/models/TaskStatus.ts b/src/models/TaskStatus.ts index d7fd5e5..dbea2b2 100644 --- a/src/models/TaskStatus.ts +++ b/src/models/TaskStatus.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ContainerStatus } from '../models/ContainerStatus.js'; @@ -17,11 +25,16 @@ import { TaskState } from '../models/TaskState.js'; /** * represents the status of a task. */ -export class TaskStatus { - 'Timestamp'?: string; - 'State'?: TaskState; - 'Message'?: string; - 'Err'?: string; - 'ContainerStatus'?: ContainerStatus; - 'PortStatus'?: PortStatus; +export interface TaskStatus { + Timestamp?: string; + + State?: TaskState; + + Message?: string; + + Err?: string; + + ContainerStatus?: ContainerStatus; + + PortStatus?: PortStatus; } diff --git a/src/models/ThrottleDevice.ts b/src/models/ThrottleDevice.ts index e25ae7a..12a66bd 100644 --- a/src/models/ThrottleDevice.ts +++ b/src/models/ThrottleDevice.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class ThrottleDevice { +export interface ThrottleDevice { /** * Device path */ - 'Path'?: string; + Path?: string; + /** * Rate */ - 'Rate'?: number; + Rate?: number; } diff --git a/src/models/UnlockKeyResponse.ts b/src/models/UnlockKeyResponse.ts index 8a7714b..8d7eabb 100644 --- a/src/models/UnlockKeyResponse.ts +++ b/src/models/UnlockKeyResponse.ts @@ -1,18 +1,26 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class UnlockKeyResponse { +export interface UnlockKeyResponse { /** - * The swarm\'s unlock key. + * The swarm\'s unlock key. */ - 'UnlockKey'?: string; + UnlockKey?: string; } diff --git a/src/models/Volume.ts b/src/models/Volume.ts index 86b8e8a..98cd4fb 100644 --- a/src/models/Volume.ts +++ b/src/models/Volume.ts @@ -1,56 +1,70 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterVolume } from '../models/ClusterVolume.js'; import { VolumeUsageData } from '../models/VolumeUsageData.js'; -export class Volume { +export interface Volume { /** * Name of the volume. */ - 'Name': string; + Name: string; + /** * Name of the volume driver used by the volume. */ - 'Driver': string; + Driver: string; + /** * Mount path of the volume on the host. */ - 'Mountpoint': string; + Mountpoint: string; + /** * Date/Time the volume was created. */ - 'CreatedAt'?: string; + CreatedAt?: string; + /** - * Low-level details about the volume, provided by the volume driver. Details are returned as a map with key/value pairs: `{\"key\":\"value\",\"key2\":\"value2\"}`. The `Status` field is optional, and is omitted if the volume driver does not support this feature. + * Low-level details about the volume, provided by the volume driver. Details are returned as a map with key/value pairs: `{\"key\":\"value\",\"key2\":\"value2\"}`. The `Status` field is optional, and is omitted if the volume driver does not support this feature. */ - 'Status'?: { [key: string]: any }; + Status?: { [key: string]: any }; + /** * User-defined key/value metadata. */ - 'Labels': { [key: string]: string }; + Labels: { [key: string]: string }; + /** - * The level at which the volume exists. Either `global` for cluster-wide, or `local` for machine level. + * The level at which the volume exists. Either `global` for cluster-wide, or `local` for machine level. */ - 'Scope': VolumeScopeEnum; - 'ClusterVolume'?: ClusterVolume; + Scope: VolumeScopeEnum; + + ClusterVolume?: ClusterVolume; + /** * The driver specific options used when creating the volume. */ - 'Options': { [key: string]: string }; - 'UsageData'?: VolumeUsageData | null; -} + Options: { [key: string]: string }; -export enum VolumeScopeEnum { - Local = 'local', - Global = 'global', + UsageData?: VolumeUsageData | null; } + +export type VolumeScopeEnum = 'local' | 'global'; diff --git a/src/models/VolumeCreateOptions.ts b/src/models/VolumeCreateOptions.ts index 009d2a9..d3ff40c 100644 --- a/src/models/VolumeCreateOptions.ts +++ b/src/models/VolumeCreateOptions.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterVolumeSpec } from '../models/ClusterVolumeSpec.js'; @@ -15,22 +23,26 @@ import { ClusterVolumeSpec } from '../models/ClusterVolumeSpec.js'; /** * Volume configuration */ -export class VolumeCreateOptions { +export interface VolumeCreateOptions { /** - * The new volume\'s name. If not specified, Docker generates a name. + * The new volume\'s name. If not specified, Docker generates a name. */ - 'Name'?: string; + Name?: string; + /** * Name of the volume driver to use. */ - 'Driver'?: string; + Driver?: string; + /** * A mapping of driver options and values. These options are passed directly to the driver and are driver specific. */ - 'DriverOpts'?: { [key: string]: string }; + DriverOpts?: { [key: string]: string }; + /** * User-defined key/value metadata. */ - 'Labels'?: { [key: string]: string }; - 'ClusterVolumeSpec'?: ClusterVolumeSpec; + Labels?: { [key: string]: string }; + + ClusterVolumeSpec?: ClusterVolumeSpec; } diff --git a/src/models/VolumeListResponse.ts b/src/models/VolumeListResponse.ts index 6bed7de..8e2fb7f 100644 --- a/src/models/VolumeListResponse.ts +++ b/src/models/VolumeListResponse.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { Volume } from '../models/Volume.js'; @@ -15,13 +23,14 @@ import { Volume } from '../models/Volume.js'; /** * Volume list response */ -export class VolumeListResponse { +export interface VolumeListResponse { /** * List of volumes */ - 'Volumes'?: Array; + Volumes?: Array; + /** * Warnings that occurred when fetching the list of volumes. */ - 'Warnings'?: Array; + Warnings?: Array; } diff --git a/src/models/VolumePruneResponse.ts b/src/models/VolumePruneResponse.ts index d7e4c47..cb51e3e 100644 --- a/src/models/VolumePruneResponse.ts +++ b/src/models/VolumePruneResponse.ts @@ -1,22 +1,31 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ -export class VolumePruneResponse { +export interface VolumePruneResponse { /** * Volumes that were deleted */ - 'VolumesDeleted'?: Array; + VolumesDeleted?: Array; + /** * Disk space reclaimed in bytes */ - 'SpaceReclaimed'?: number; + SpaceReclaimed?: number; } diff --git a/src/models/VolumeUpdateRequest.ts b/src/models/VolumeUpdateRequest.ts index 5487925..3490bc7 100644 --- a/src/models/VolumeUpdateRequest.ts +++ b/src/models/VolumeUpdateRequest.ts @@ -1,13 +1,21 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ import { ClusterVolumeSpec } from '../models/ClusterVolumeSpec.js'; @@ -15,6 +23,6 @@ import { ClusterVolumeSpec } from '../models/ClusterVolumeSpec.js'; /** * Volume configuration */ -export class VolumeUpdateRequest { - 'Spec'?: ClusterVolumeSpec; +export interface VolumeUpdateRequest { + Spec?: ClusterVolumeSpec; } diff --git a/src/models/VolumeUsageData.ts b/src/models/VolumeUsageData.ts index ab3dd65..7149875 100644 --- a/src/models/VolumeUsageData.ts +++ b/src/models/VolumeUsageData.ts @@ -1,25 +1,34 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ /** * Usage details about the volume. This information is used by the `GET /system/df` endpoint, and omitted in other endpoints. */ -export class VolumeUsageData { +export interface VolumeUsageData { /** - * Amount of disk space used by the volume (in bytes). This information is only available for volumes created with the `\"local\"` volume driver. For volumes created with other volume drivers, this field is set to `-1` (\"not available\") + * Amount of disk space used by the volume (in bytes). This information is only available for volumes created with the `\"local\"` volume driver. For volumes created with other volume drivers, this field is set to `-1` (\"not available\") */ - 'Size': number; + Size: number; + /** - * The number of containers referencing this volume. This field is set to `-1` if the reference-count is not available. + * The number of containers referencing this volume. This field is set to `-1` if the reference-count is not available. */ - 'RefCount': number; + RefCount: number; } diff --git a/src/models/index.ts b/src/models/index.ts index 0ea28de..6b5cc45 100644 --- a/src/models/index.ts +++ b/src/models/index.ts @@ -1,14 +1,23 @@ -/** - * Docker Engine API - * The Engine API is an HTTP API served by Docker Engine. It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. Most of the client\'s commands map directly to API endpoints (e.g. `docker ps` is `GET /containers/json`). The notable exception is running containers, which consists of several API calls. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call. The body of the response will be JSON in the following format: ``` { \"message\": \"page not found\" } ``` # Versioning The API is usually changed in each release, so API calls are versioned to ensure that clients don\'t break. To lock to a specific version of the API, you prefix the URL with its version, for example, call `/v1.30/info` to use the v1.30 version of the `/info` endpoint. If the API version specified in the URL is not supported by the daemon, a HTTP `400 Bad Request` error message is returned. If you omit the version-prefix, the current version of the API (v1.50) is used. For example, calling `/info` is the same as calling `/v1.52/info`. Using the API without a version-prefix is deprecated and will be removed in a future release. Engine releases in the near future should support this version of the API, so your client will continue to work even if it is talking to a newer Engine. The API uses an open schema model, which means the server may add extra properties to responses. Likewise, the server will ignore any extra query parameters and request body properties. When you write clients, you need to ignore additional properties in responses to ensure they do not break when talking to newer daemons. # Authentication Authentication for registries is handled client side. The client has to send authentication details to various endpoints that need to communicate with registries, such as `POST /images/(name)/push`. These are sent as `X-Registry-Auth` header as a [base64url encoded](https://tools.ietf.org/html/rfc4648#section-5) (JSON) string with the following structure: ``` { \"username\": \"string\", \"password\": \"string\", \"email\": \"string\", \"serveraddress\": \"string\" } ``` The `serveraddress` is a domain/IP without a protocol. Throughout this structure, double quotes are required. If you have already got an identity token from the [`/auth` endpoint](#operation/SystemAuth), you can just pass this instead of credentials: ``` { \"identitytoken\": \"9cbaf023786cd7...\" } ``` - * - * OpenAPI spec version: 1.52 - * - * - * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). - * https://openapi-generator.tech - * Do not edit the class manually. +/* + Copyright 2025 Docker SDK authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + https://openapi-generator.tech + Do not edit the class manually. */ +export * from './FileInfo.js'; export * from './Address.js'; export * from './AuthConfig.js'; @@ -243,5 +252,3 @@ export * from './VolumeListResponse.js'; export * from './VolumePruneResponse.js'; export * from './VolumeUpdateRequest.js'; export * from './VolumeUsageData.js'; - -export * from './FileInfo.js'; diff --git a/templates/model/licenseInfo.mustache b/templates/licenseInfo.mustache similarity index 99% rename from templates/model/licenseInfo.mustache rename to templates/licenseInfo.mustache index 498084a..65c12d6 100644 --- a/templates/model/licenseInfo.mustache +++ b/templates/licenseInfo.mustache @@ -1,4 +1,4 @@ - /* +/* Copyright 2025 Docker SDK authors Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/templates/model/index.mustache b/templates/model/index.mustache index 213c15d..963ac34 100644 --- a/templates/model/index.mustache +++ b/templates/model/index.mustache @@ -1,4 +1,6 @@ {{>licenseInfo}} +export * from './FileInfo.js'; + {{#models}} {{#model}} export * from './{{{ classname }}}{{importFileExtension}}' diff --git a/templates/model/model.mustache b/templates/model/model.mustache index 9df512c..da40e05 100644 --- a/templates/model/model.mustache +++ b/templates/model/model.mustache @@ -1,41 +1,39 @@ {{>licenseInfo}} + {{#models}} {{#model}} {{#tsImports}} import { {{classname}} } from '{{filename}}{{importFileExtension}}'; -{{/tsImports}} +{{#-last}} +{{/-last}} +{{/tsImports}} {{#description}} /** -* {{{.}}} -*/ + * {{{.}}} + */ {{/description}} {{^isEnum}} {{#oneOf}} {{#-first}}{{>model/modelOneOf}}{{/-first}} {{/oneOf}} {{^oneOf}} -export class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{ +export interface {{classname}} { {{#vars}} + {{#description}} /** - * {{{.}}} - */ + * {{.}} + */ {{/description}} - '{{#lambda.titlecase}}{{name}}{{/lambda.titlecase}}'{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{#isNullable}} | null{{/isNullable}}; + {{#lambda.titlecase}}{{name}}{{/lambda.titlecase}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{#isNullable}} | null{{/isNullable}}; {{/vars}} } {{#hasEnums}} {{#vars}} {{#isEnum}} -export enum {{classname}}{{enumName}} { - {{#allowableValues}} - {{#enumVars}} - {{name}} = {{{value}}}{{^-last}},{{/-last}} - {{/enumVars}} - {{/allowableValues}} -} +export type {{classname}}{{enumName}} = {{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}} | {{/-last}}{{/enumVars}}{{/allowableValues}}; {{/isEnum}} {{/vars}} @@ -43,13 +41,7 @@ export enum {{classname}}{{enumName}} { {{/oneOf}} {{/isEnum}} {{#isEnum}} -export enum {{classname}} { - {{#allowableValues}} - {{#enumVars}} - {{name}} = {{{value}}}{{^-last}},{{/-last}} - {{/enumVars}} - {{/allowableValues}} -} +export type {{classname}} = {{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}} | {{/-last}}{{/enumVars}}{{/allowableValues}}; {{/isEnum}} {{/model}} {{/models}} \ No newline at end of file