docker-engine 0.1.1 → 0.2.0

data/rbi/docker_engine/models/secret.rbi

@@ -0,0 +1,125 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class Secret < DockerEngine::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(DockerEngine::Secret, DockerEngine::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_at
+
+      sig { params(created_at: String).void }
+      attr_writer :created_at
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      sig { returns(T.nilable(DockerEngine::Spec)) }
+      attr_reader :spec
+
+      sig { params(spec: DockerEngine::Spec::OrHash).void }
+      attr_writer :spec
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: String).void }
+      attr_writer :updated_at
+
+      # 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.
+      sig { returns(T.nilable(DockerEngine::Secret::Version)) }
+      attr_reader :version
+
+      sig { params(version: DockerEngine::Secret::Version::OrHash).void }
+      attr_writer :version
+
+      sig do
+        params(
+          created_at: String,
+          id: String,
+          spec: DockerEngine::Spec::OrHash,
+          updated_at: String,
+          version: DockerEngine::Secret::Version::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        created_at: nil,
+        id: nil,
+        spec: nil,
+        updated_at: nil,
+        # 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.
+        version: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            created_at: String,
+            id: String,
+            spec: DockerEngine::Spec,
+            updated_at: String,
+            version: DockerEngine::Secret::Version
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Version < DockerEngine::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngine::Secret::Version,
+              DockerEngine::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :index
+
+        sig { params(index: Integer).void }
+        attr_writer :index
+
+        # 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.
+        sig { params(index: Integer).returns(T.attached_class) }
+        def self.new(index: nil)
+        end
+
+        sig { override.returns({ index: Integer }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/secret_create_params.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class SecretCreateParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::SecretCreateParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(DockerEngine::SecretCreateParams::Spec)) }
+      attr_reader :spec
+
+      sig { params(spec: DockerEngine::SecretCreateParams::Spec::OrHash).void }
+      attr_writer :spec
+
+      sig do
+        params(
+          spec: DockerEngine::SecretCreateParams::Spec::OrHash,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(spec: nil, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            spec: DockerEngine::SecretCreateParams::Spec,
+            request_options: DockerEngine::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Spec < DockerEngine::Models::Spec
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngine::SecretCreateParams::Spec,
+              DockerEngine::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.attached_class) }
+        def self.new
+        end
+
+        sig { override.returns({}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/secret_create_response.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class SecretCreateResponse < DockerEngine::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::Models::SecretCreateResponse,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # The id of the newly created object.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Response to an API call that returns just an Id
+      sig { params(id: String).returns(T.attached_class) }
+      def self.new(
+        # The id of the newly created object.
+        id:
+      )
+      end
+
+      sig { override.returns({ id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/secret_delete_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class SecretDeleteParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::SecretDeleteParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: DockerEngine::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig do
+        override.returns({ request_options: DockerEngine::RequestOptions })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/secret_inspect_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class SecretInspectParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::SecretInspectParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: DockerEngine::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig do
+        override.returns({ request_options: DockerEngine::RequestOptions })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/secret_list_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class SecretListParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(DockerEngine::SecretListParams, DockerEngine::Internal::AnyHash)
+        end
+
+      # A JSON encoded value of the filters (a `map[string][]string`) to process on the
+      # secrets list.
+      #
+      # Available filters:
+      #
+      # - `id=<secret id>`
+      # - `label=<key> or label=<key>=value`
+      # - `name=<secret name>`
+      # - `names=<secret name>`
+      sig { returns(T.nilable(String)) }
+      attr_reader :filters
+
+      sig { params(filters: String).void }
+      attr_writer :filters
+
+      sig do
+        params(
+          filters: String,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A JSON encoded value of the filters (a `map[string][]string`) to process on the
+        # secrets list.
+        #
+        # Available filters:
+        #
+        # - `id=<secret id>`
+        # - `label=<key> or label=<key>=value`
+        # - `name=<secret name>`
+        # - `names=<secret name>`
+        filters: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { filters: String, request_options: DockerEngine::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/secret_list_response.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    SecretListResponse =
+      T.let(
+        DockerEngine::Internal::Type::ArrayOf[DockerEngine::Secret],
+        DockerEngine::Internal::Type::Converter
+      )
+  end
+end

data/rbi/docker_engine/models/secret_update_params.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class SecretUpdateParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::SecretUpdateParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # The version number of the secret object being updated. This is required to avoid
+      # conflicting writes.
+      sig { returns(Integer) }
+      attr_accessor :version
+
+      sig do
+        params(
+          version: Integer,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The version number of the secret object being updated. This is required to avoid
+        # conflicting writes.
+        version:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { version: Integer, request_options: DockerEngine::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/service_logs_params.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class ServiceLogsParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::ServiceLogsParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # Show service context and extra details provided to logs.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :details
+
+      sig { params(details: T::Boolean).void }
+      attr_writer :details
+
+      # Keep connection after returning logs.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :follow
+
+      sig { params(follow: T::Boolean).void }
+      attr_writer :follow
+
+      # Only return logs since this time, as a UNIX timestamp
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :since
+
+      sig { params(since: Integer).void }
+      attr_writer :since
+
+      # Return logs from `stderr`
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stderr
+
+      sig { params(stderr: T::Boolean).void }
+      attr_writer :stderr
+
+      # Return logs from `stdout`
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stdout
+
+      sig { params(stdout: T::Boolean).void }
+      attr_writer :stdout
+
+      # Only return this number of log lines from the end of the logs. Specify as an
+      # integer or `all` to output all log lines.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tail
+
+      sig { params(tail: String).void }
+      attr_writer :tail
+
+      # Add timestamps to every log line
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :timestamps
+
+      sig { params(timestamps: T::Boolean).void }
+      attr_writer :timestamps
+
+      sig do
+        params(
+          details: T::Boolean,
+          follow: T::Boolean,
+          since: Integer,
+          stderr: T::Boolean,
+          stdout: T::Boolean,
+          tail: String,
+          timestamps: T::Boolean,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Show service context and extra details provided to logs.
+        details: nil,
+        # Keep connection after returning logs.
+        follow: nil,
+        # Only return logs since this time, as a UNIX timestamp
+        since: nil,
+        # Return logs from `stderr`
+        stderr: nil,
+        # Return logs from `stdout`
+        stdout: nil,
+        # Only return this number of log lines from the end of the logs. Specify as an
+        # integer or `all` to output all log lines.
+        tail: nil,
+        # Add timestamps to every log line
+        timestamps: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            details: T::Boolean,
+            follow: T::Boolean,
+            since: Integer,
+            stderr: T::Boolean,
+            stdout: T::Boolean,
+            tail: String,
+            timestamps: T::Boolean,
+            request_options: DockerEngine::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/service_update_params.rbi

@@ -0,0 +1,163 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class ServiceUpdateParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::ServiceUpdateParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # The version number of the service object being updated. This is required to
+      # avoid conflicting writes. This version number should be the value as currently
+      # set on the service _before_ the update. You can find the current version by
+      # calling `GET /services/{id}`
+      sig { returns(Integer) }
+      attr_accessor :version
+
+      # User modifiable configuration for a service.
+      sig { returns(DockerEngine::ServiceUpdateParams::Spec) }
+      attr_reader :spec
+
+      sig { params(spec: DockerEngine::ServiceUpdateParams::Spec::OrHash).void }
+      attr_writer :spec
+
+      # If the `X-Registry-Auth` header is not specified, this parameter indicates where
+      # to find registry authorization credentials.
+      sig do
+        returns(
+          T.nilable(
+            DockerEngine::ServiceUpdateParams::RegistryAuthFrom::OrSymbol
+          )
+        )
+      end
+      attr_reader :registry_auth_from
+
+      sig do
+        params(
+          registry_auth_from:
+            DockerEngine::ServiceUpdateParams::RegistryAuthFrom::OrSymbol
+        ).void
+      end
+      attr_writer :registry_auth_from
+
+      # Set to this parameter to `previous` to cause a server-side rollback to the
+      # previous service spec. The supplied spec will be ignored in this case.
+      sig { returns(T.nilable(String)) }
+      attr_reader :rollback
+
+      sig { params(rollback: String).void }
+      attr_writer :rollback
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :x_registry_auth
+
+      sig { params(x_registry_auth: String).void }
+      attr_writer :x_registry_auth
+
+      sig do
+        params(
+          version: Integer,
+          spec: DockerEngine::ServiceUpdateParams::Spec::OrHash,
+          registry_auth_from:
+            DockerEngine::ServiceUpdateParams::RegistryAuthFrom::OrSymbol,
+          rollback: String,
+          x_registry_auth: String,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The version number of the service object being updated. This is required to
+        # avoid conflicting writes. This version number should be the value as currently
+        # set on the service _before_ the update. You can find the current version by
+        # calling `GET /services/{id}`
+        version:,
+        # User modifiable configuration for a service.
+        spec:,
+        # If the `X-Registry-Auth` header is not specified, this parameter indicates where
+        # to find registry authorization credentials.
+        registry_auth_from: nil,
+        # Set to this parameter to `previous` to cause a server-side rollback to the
+        # previous service spec. The supplied spec will be ignored in this case.
+        rollback: nil,
+        x_registry_auth: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            version: Integer,
+            spec: DockerEngine::ServiceUpdateParams::Spec,
+            registry_auth_from:
+              DockerEngine::ServiceUpdateParams::RegistryAuthFrom::OrSymbol,
+            rollback: String,
+            x_registry_auth: String,
+            request_options: DockerEngine::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Spec < DockerEngine::Models::Spec
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngine::ServiceUpdateParams::Spec,
+              DockerEngine::Internal::AnyHash
+            )
+          end
+
+        # User modifiable configuration for a service.
+        sig { returns(T.attached_class) }
+        def self.new
+        end
+
+        sig { override.returns({}) }
+        def to_hash
+        end
+      end
+
+      # If the `X-Registry-Auth` header is not specified, this parameter indicates where
+      # to find registry authorization credentials.
+      module RegistryAuthFrom
+        extend DockerEngine::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, DockerEngine::ServiceUpdateParams::RegistryAuthFrom)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SPEC =
+          T.let(
+            :spec,
+            DockerEngine::ServiceUpdateParams::RegistryAuthFrom::TaggedSymbol
+          )
+        PREVIOUS_SPEC =
+          T.let(
+            :"previous-spec",
+            DockerEngine::ServiceUpdateParams::RegistryAuthFrom::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              DockerEngine::ServiceUpdateParams::RegistryAuthFrom::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end