docker-engine-api 0.2.1

data/rbi/docker_engine_api/models/task_inspect_params.rbi

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

data/rbi/docker_engine_api/models/task_list_params.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class TaskListParams < DockerEngineAPI::Internal::Type::BaseModel
+      extend DockerEngineAPI::Internal::Type::RequestParameters::Converter
+      include DockerEngineAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::TaskListParams,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # A JSON encoded value of the filters (a `map[string][]string`) to process on the
+      # tasks list.
+      #
+      # Available filters:
+      #
+      # - `desired-state=(running | shutdown | accepted)`
+      # - `id=<task id>`
+      # - `label=key` or `label="key=value"`
+      # - `name=<task name>`
+      # - `node=<node id or name>`
+      # - `service=<service name>`
+      sig { returns(T.nilable(String)) }
+      attr_reader :filters
+
+      sig { params(filters: String).void }
+      attr_writer :filters
+
+      sig do
+        params(
+          filters: String,
+          request_options: DockerEngineAPI::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
+        # tasks list.
+        #
+        # Available filters:
+        #
+        # - `desired-state=(running | shutdown | accepted)`
+        # - `id=<task id>`
+        # - `label=key` or `label="key=value"`
+        # - `name=<task name>`
+        # - `node=<node id or name>`
+        # - `service=<service name>`
+        filters: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { filters: String, request_options: DockerEngineAPI::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/task_list_response.rbi

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

data/rbi/docker_engine_api/models/task_logs_params.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class TaskLogsParams < DockerEngineAPI::Internal::Type::BaseModel
+      extend DockerEngineAPI::Internal::Type::RequestParameters::Converter
+      include DockerEngineAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::TaskLogsParams,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # Show task 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: DockerEngineAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Show task 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: DockerEngineAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/top_response.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class TopResponse < DockerEngineAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::TopResponse,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # Each process running in the container, where each process is an array of values
+      # corresponding to the titles.
+      sig { returns(T.nilable(T::Array[T::Array[String]])) }
+      attr_reader :processes
+
+      sig { params(processes: T::Array[T::Array[String]]).void }
+      attr_writer :processes
+
+      # The ps column titles
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :titles
+
+      sig { params(titles: T::Array[String]).void }
+      attr_writer :titles
+
+      # Container "top" response.
+      sig do
+        params(
+          processes: T::Array[T::Array[String]],
+          titles: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Each process running in the container, where each process is an array of values
+        # corresponding to the titles.
+        processes: nil,
+        # The ps column titles
+        titles: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { processes: T::Array[T::Array[String]], titles: T::Array[String] }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/update_response.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class UpdateResponse < DockerEngineAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::UpdateResponse,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # Warnings encountered when updating the container.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :warnings
+
+      sig { params(warnings: T::Array[String]).void }
+      attr_writer :warnings
+
+      # Response for a successful container-update.
+      sig { params(warnings: T::Array[String]).returns(T.attached_class) }
+      def self.new(
+        # Warnings encountered when updating the container.
+        warnings: nil
+      )
+      end
+
+      sig { override.returns({ warnings: T::Array[String] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/version.rbi

@@ -0,0 +1,256 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class Version < DockerEngineAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(DockerEngineAPI::Version, DockerEngineAPI::Internal::AnyHash)
+        end
+
+      # The default (and highest) API version that is supported by the daemon
+      sig { returns(T.nilable(String)) }
+      attr_reader :api_version
+
+      sig { params(api_version: String).void }
+      attr_writer :api_version
+
+      # Architecture of the daemon, 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).
+      sig { returns(T.nilable(String)) }
+      attr_reader :arch
+
+      sig { params(arch: String).void }
+      attr_writer :arch
+
+      # The date and time that the daemon was compiled.
+      sig { returns(T.nilable(String)) }
+      attr_reader :build_time
+
+      sig { params(build_time: String).void }
+      attr_writer :build_time
+
+      # Information about system components
+      sig { returns(T.nilable(T::Array[DockerEngineAPI::Version::Component])) }
+      attr_reader :components
+
+      sig do
+        params(
+          components: T::Array[DockerEngineAPI::Version::Component::OrHash]
+        ).void
+      end
+      attr_writer :components
+
+      # Indicates if the daemon is started with experimental features enabled.
+      #
+      # This field is omitted when empty / false.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :experimental
+
+      sig { params(experimental: T::Boolean).void }
+      attr_writer :experimental
+
+      # The Git commit of the source code that was used to build the daemon
+      sig { returns(T.nilable(String)) }
+      attr_reader :git_commit
+
+      sig { params(git_commit: String).void }
+      attr_writer :git_commit
+
+      # The version Go used to compile the daemon, and the version of the Go runtime in
+      # use.
+      sig { returns(T.nilable(String)) }
+      attr_reader :go_version
+
+      sig { params(go_version: String).void }
+      attr_writer :go_version
+
+      # The kernel version (`uname -r`) that the daemon is running on.
+      #
+      # This field is omitted when empty.
+      sig { returns(T.nilable(String)) }
+      attr_reader :kernel_version
+
+      sig { params(kernel_version: String).void }
+      attr_writer :kernel_version
+
+      # The minimum API version that is supported by the daemon
+      sig { returns(T.nilable(String)) }
+      attr_reader :min_api_version
+
+      sig { params(min_api_version: String).void }
+      attr_writer :min_api_version
+
+      # The operating system that the daemon is running on ("linux" or "windows")
+      sig { returns(T.nilable(String)) }
+      attr_reader :os
+
+      sig { params(os: String).void }
+      attr_writer :os
+
+      sig { returns(T.nilable(DockerEngineAPI::Version::Platform)) }
+      attr_reader :platform
+
+      sig { params(platform: DockerEngineAPI::Version::Platform::OrHash).void }
+      attr_writer :platform
+
+      # The version of the daemon
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { params(version: String).void }
+      attr_writer :version
+
+      # Response of Engine API: GET "/version"
+      sig do
+        params(
+          api_version: String,
+          arch: String,
+          build_time: String,
+          components: T::Array[DockerEngineAPI::Version::Component::OrHash],
+          experimental: T::Boolean,
+          git_commit: String,
+          go_version: String,
+          kernel_version: String,
+          min_api_version: String,
+          os: String,
+          platform: DockerEngineAPI::Version::Platform::OrHash,
+          version: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The default (and highest) API version that is supported by the daemon
+        api_version: nil,
+        # Architecture of the daemon, 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).
+        arch: nil,
+        # The date and time that the daemon was compiled.
+        build_time: nil,
+        # Information about system components
+        components: nil,
+        # Indicates if the daemon is started with experimental features enabled.
+        #
+        # This field is omitted when empty / false.
+        experimental: nil,
+        # The Git commit of the source code that was used to build the daemon
+        git_commit: nil,
+        # The version Go used to compile the daemon, and the version of the Go runtime in
+        # use.
+        go_version: nil,
+        # The kernel version (`uname -r`) that the daemon is running on.
+        #
+        # This field is omitted when empty.
+        kernel_version: nil,
+        # The minimum API version that is supported by the daemon
+        min_api_version: nil,
+        # The operating system that the daemon is running on ("linux" or "windows")
+        os: nil,
+        platform: nil,
+        # The version of the daemon
+        version: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            api_version: String,
+            arch: String,
+            build_time: String,
+            components: T::Array[DockerEngineAPI::Version::Component],
+            experimental: T::Boolean,
+            git_commit: String,
+            go_version: String,
+            kernel_version: String,
+            min_api_version: String,
+            os: String,
+            platform: DockerEngineAPI::Version::Platform,
+            version: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Component < DockerEngineAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineAPI::Version::Component,
+              DockerEngineAPI::Internal::AnyHash
+            )
+          end
+
+        # Name of the component
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Version of the component
+        sig { returns(String) }
+        attr_accessor :version
+
+        # 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.
+        sig { returns(T.nilable(T.anything)) }
+        attr_accessor :details
+
+        sig do
+          params(
+            name: String,
+            version: String,
+            details: T.nilable(T.anything)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Name of the component
+          name:,
+          # Version of the component
+          version:,
+          # 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: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { name: String, version: String, details: T.nilable(T.anything) }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Platform < DockerEngineAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineAPI::Version::Platform,
+              DockerEngineAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { params(name: String).returns(T.attached_class) }
+        def self.new(name:)
+        end
+
+        sig { override.returns({ name: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end