capsium 0.2.0 → 0.6.0

data/sig/capsium/log_buffer.rbs

@@ -0,0 +1,30 @@
+module Capsium
+  # A small thread-safe ring buffer of timestamped log entries with a
+  # fixed capacity: when full, the oldest entry is dropped.
+  class LogBuffer
+    DEFAULT_CAPACITY: Integer
+
+    # One buffer entry: a UTC timestamp and a message.
+    class Entry
+      def self.new: (timestamp: Time, message: String) -> void
+
+      def timestamp: () -> Time
+      def message: () -> String
+
+      # "2026-07-19T15:00:00Z message"
+      def line: () -> String
+    end
+
+    attr_reader capacity: Integer
+
+    def initialize: (?capacity: Integer capacity) -> void
+
+    def add: (String message, ?timestamp: Time timestamp) -> LogBuffer
+
+    # The last n entries, oldest first.
+    def last: (Integer count) -> Array[Entry]
+
+    # The last n entries as formatted lines, oldest first.
+    def lines: (Integer count) -> Array[String]
+  end
+end

data/sig/capsium/package/authentication.rbs

@@ -0,0 +1,23 @@
+module Capsium
+  class Package
+    # Loads a package's authentication.json (ARCHITECTURE.md section 4b).
+    class Authentication
+      attr_reader path: String
+      attr_reader config: AuthenticationConfig?
+
+      def initialize: (String path) -> void
+
+      def present?: () -> bool
+
+      def basic_auth: () -> BasicAuthConfig?
+
+      def oauth2: () -> OAuth2Config?
+
+      # Whether any authentication method is enabled.
+      def enabled?: () -> bool
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+  end
+end

data/sig/capsium/package/authentication_config.rbs

@@ -0,0 +1,71 @@
+module Capsium
+  class Package
+    # The "basicAuth" object of authentication.json (ARCHITECTURE.md
+    # section 4b): Apache-style Basic authentication verified against an
+    # htpasswd file.
+    class BasicAuthConfig
+      attr_accessor enabled: bool
+      attr_accessor passwd_file: String?
+      attr_accessor realm: String
+
+      def initialize: (?enabled: bool enabled, ?passwd_file: String? passwd_file,
+                       ?realm: String? realm) -> void
+
+      def enabled?: () -> bool
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+
+    # The "oauth2" object of authentication.json: an OAuth2
+    # authorization-code flow. The client secret is NEVER read from the
+    # package — it comes from deploy.json or reactor configuration.
+    class OAuth2Config
+      attr_accessor enabled: bool
+      attr_accessor provider: String?
+      attr_accessor client_id: String?
+      attr_accessor authorization_url: String?
+      attr_accessor token_url: String?
+      attr_accessor userinfo_url: String?
+      attr_accessor redirect_path: String
+      attr_accessor scopes: Array[String]
+
+      def initialize: (?enabled: bool enabled, ?provider: String? provider,
+                       ?client_id: String? client_id,
+                       ?authorization_url: String? authorization_url,
+                       ?token_url: String? token_url,
+                       ?userinfo_url: String? userinfo_url,
+                       ?redirect_path: String? redirect_path,
+                       ?scopes: Array[String] scopes) -> void
+
+      def enabled?: () -> bool
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+
+    # The "authentication" object of authentication.json.
+    class AuthenticationData
+      attr_accessor basic_auth: BasicAuthConfig?
+      attr_accessor oauth2: OAuth2Config?
+
+      def initialize: (?basic_auth: BasicAuthConfig? basic_auth,
+                       ?oauth2: OAuth2Config? oauth2) -> void
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+
+    # Canonical authentication.json model (ARCHITECTURE.md section 4b).
+    class AuthenticationConfig
+      attr_accessor authentication: AuthenticationData?
+
+      def initialize: (?authentication: AuthenticationData? authentication) -> void
+
+      def self.from_json: (String json) -> instance
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+  end
+end

data/sig/capsium/package/bundle.rbs

@@ -0,0 +1,43 @@
+module Capsium
+  class Package
+    # Bundled dependencies of an encapsulated (self-contained) package:
+    # dependency .cap files embedded under packages/ with a
+    # packages/index.json manifest mapping each dependency GUID to its
+    # file, version and SHA-256. Bundled dependencies resolve first at
+    # load time, before the store -> registry chain.
+    class Bundle
+      DIRECTORY: String
+      INDEX_FILE: String
+
+      # One bundled dependency: the absolute .cap path, its version and
+      # the SHA-256 recorded in the manifest.
+      class Entry
+        def self.new: (String file, String version, String sha256) -> void
+
+        def file: () -> String
+        def version: () -> String
+        def sha256: () -> String
+      end
+
+      attr_reader entries: Hash[String, Entry]
+
+      def initialize: (String? package_path, ?Hash[String, Entry]? entries) -> void
+
+      # Embeds the resolved dependency .cap files (guid => .cap path
+      # pairs) into the package directory at package_path and writes the
+      # packages/index.json manifest. Returns the manifest hash.
+      def self.write: (String package_path, Array[[String, String]] resolutions) -> Hash[String, Hash[String, String]]
+
+      # Whether this bundle embeds any dependency.
+      def present?: () -> bool
+
+      # Merges an inherited (ancestor) bundle underneath this one; own
+      # entries win on GUID conflicts.
+      def merged_with: (Bundle? other) -> Bundle
+
+      # The absolute .cap path for a bundled dependency, or nil when the
+      # GUID is not bundled.
+      def resolve_path: (String guid, String range, chain: Array[String] chain) -> String?
+    end
+  end
+end

data/sig/capsium/package/cipher.rbs

@@ -0,0 +1,62 @@
+module Capsium
+  class Package
+    # Encrypts and decrypts whole Capsium packages (05x-packaging
+    # "Encryption", 05x-security "Encrypted information"). An encrypted
+    # .cap is a zip containing metadata.json (cleartext), signature.json
+    # (the encryption envelope) and package.enc (AES-256-GCM of the inner
+    # plaintext .cap zip). The random DEK is wrapped with the recipient's
+    # RSA public key using OAEP with SHA-256. OCB/OpenPGP are out of
+    # scope.
+    class Cipher
+      ALGORITHM: String
+      KEY_MANAGEMENT: String
+      CIPHER_NAME: String
+      ENCRYPTED_FILE: String
+      ENVELOPE_FILE: String
+      RSA_OPTIONS: Hash[String, String]
+
+      # Structural problems: unreadable input, missing zip entries,
+      # unsupported envelope algorithms, unloadable keys.
+      class CipherError < Capsium::Error
+      end
+
+      # An encrypted package was opened without a private key.
+      class KeyRequiredError < CipherError
+      end
+
+      # Decryption failed: wrong private key or tampered ciphertext.
+      class DecryptionError < CipherError
+      end
+
+      # Whether the path (.cap file or uncompressed directory) is an
+      # encrypted package, i.e. contains package.enc.
+      def self.encrypted?: (String | Pathname path) -> bool
+
+      # The keyManagement declared by the encryption envelope of the
+      # path (.cap file or uncompressed directory), or nil when the
+      # envelope is absent or unreadable.
+      def self.key_management: (String | Pathname path) -> String?
+
+      # The cipher instance matching the envelope's keyManagement:
+      # OpenPgpCipher for OpenPGP envelopes, the RSA cipher otherwise.
+      def self.for_encrypted: (String | Pathname path) -> Cipher
+
+      # Encrypts the package at source_path (a .cap file, or a package
+      # directory which is packed first) for the recipient's RSA public
+      # key (or X.509 certificate) and writes the encrypted .cap to
+      # output_path. Returns output_path.
+      def encrypt: (String source_path, String public_key_path, String output_path) -> String
+
+      # Decrypts the encrypted package at encrypted_path (.cap file or
+      # uncompressed directory) with the recipient's RSA private key and
+      # writes the plaintext .cap to output_path. Returns output_path.
+      def decrypt: (String | Pathname encrypted_path, String private_key_path, String output_path) -> String
+
+      # Decrypts an encrypted package into a fresh temporary directory
+      # and returns the directory path. The cipher is selected from the
+      # envelope's keyManagement: OpenPGP envelopes decrypt through
+      # OpenPgpCipher, everything else through the RSA cipher.
+      def self.decrypt_to_directory: (String | Pathname source_path, String private_key_path) -> String
+    end
+  end
+end

data/sig/capsium/package/composition.rbs

@@ -0,0 +1,21 @@
+module Capsium
+  class Package
+    # Composite-package support (ARCHITECTURE.md section 4a), mixed into
+    # Package: metadata.dependencies resolution — bundled dependencies
+    # (Capsium::Package::Bundle) first, then the package store — and
+    # load-time validation of dependency resource references.
+    module Composition
+      private
+
+      def resolve_dependencies: ((Store | String)? store, (Capsium::Registry | String)? registry, Array[String] chain, ?Bundle? bundle) -> Array[ResolvedDependency]
+
+      def validate_dependency_references!: () -> void
+
+      def validate_dependency_reference: (Route route, ResolvedDependency dependency, String reference) -> void
+
+      def dependency_for: (String reference) -> ResolvedDependency?
+
+      def dependency_views: () -> Array[[String, MergedView]]
+    end
+  end
+end

data/sig/capsium/package/dataset.rbs

@@ -19,6 +19,14 @@ module Capsium
 
       def validate: () -> bool
 
+      # The parsed JSON schema for this dataset, or nil when none is
+      # declared or the file is unreadable.
+      def json_schema: () -> Hash[String, untyped]?
+
+      # Schema validation of an arbitrary candidate document (used by
+      # the reactor's writable overlay); empty when valid or schema-less.
+      def schema_errors_for: (untyped data) -> Array[String]
+
       # File-existence and schema validations; empty when valid.
       def validation_errors: () -> Array[String]
 

data/sig/capsium/package/dependency_resolver.rbs

@@ -0,0 +1,53 @@
+module Capsium
+  class Package
+    # Base error for composite-package dependency resolution
+    # (ARCHITECTURE.md section 4a).
+    class DependencyError < Capsium::Error
+    end
+
+    # No package in the store provides the dependency GUID.
+    class DependencyNotFoundError < DependencyError
+    end
+
+    # The store provides the GUID but no version satisfies the range.
+    class UnsatisfiableDependencyError < DependencyError
+    end
+
+    # A dependency cycle was detected while resolving.
+    class CircularDependencyError < DependencyError
+    end
+
+    # A dependent route references a dependency resource that is not
+    # exported (private) and therefore not visible to dependents.
+    class DependencyVisibilityError < DependencyError
+    end
+
+    # One resolved dependency: the declared GUID and range, the .cap it
+    # resolved to and the loaded package.
+    class ResolvedDependency
+      def self.new: (String guid, String range, String path, Package package) -> void
+
+      def guid: () -> String
+      def range: () -> String
+      def path: () -> String
+      def package: () -> Package
+      def version: () -> String?
+    end
+
+    # Orchestrates metadata.dependencies resolution against a package
+    # store: circularity checks plus store lookup, with a registry as
+    # install fallback for store misses.
+    class DependencyResolver
+      attr_reader store: Store
+      attr_reader registry: Capsium::Registry?
+
+      def initialize: (Store | String? store,
+                       ?registry: (Capsium::Registry | String)? registry) -> void
+
+      # The newest store .cap satisfying the dependency, installing from
+      # the configured registry on a store miss and raising typed errors
+      # for circular, missing or unsatisfiable dependencies.
+      def resolve_path: (String guid, String range, chain: Array[String] chain) -> String
+    end
+  end
+end

data/sig/capsium/package/encryption_config.rbs

@@ -0,0 +1,39 @@
+module Capsium
+  class Package
+    # The "encryption" object of signature.json in an encrypted package:
+    # the AES-256-GCM envelope. keyManagement selects how the DEK is
+    # protected: "RSA-OAEP-SHA256" carries it Base64-wrapped in
+    # encryptedDek; "OpenPGP" carries an armored OpenPGP message
+    # containing the DEK in message. iv/authTag are Base64.
+    class EncryptionEnvelope
+      attr_accessor algorithm: String?
+      attr_accessor key_management: String?
+      attr_accessor encrypted_dek: String?
+      attr_accessor message: String?
+      attr_accessor iv: String?
+      attr_accessor auth_tag: String?
+
+      def initialize: (?algorithm: String? algorithm,
+                       ?key_management: String? key_management,
+                       ?encrypted_dek: String? encrypted_dek,
+                       ?message: String? message,
+                       ?iv: String? iv,
+                       ?auth_tag: String? auth_tag) -> void
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+
+    # The signature.json file of an encrypted package.
+    class EncryptionConfig
+      attr_accessor encryption: EncryptionEnvelope?
+
+      def initialize: (?encryption: EncryptionEnvelope? encryption) -> void
+
+      def self.from_json: (String json) -> instance
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+  end
+end

data/sig/capsium/package/merged_view.rbs

@@ -0,0 +1,47 @@
+module Capsium
+  class Package
+    # The merged (overlay) view of a package's content, per ARCHITECTURE.md
+    # section 5a. Shared by Package (validation) and Reactor (serving).
+    class MergedView
+      # A single read layer: an absolute root directory mirroring the
+      # content/ tree, plus its parsed tombstone set.
+      class Layer
+        def self.new: (String root, String visibility, Set[String] tombstones) -> void
+
+        def file?: (String content_relative_path) -> bool
+
+        def absolute: (String content_relative_path) -> String
+
+        def root: () -> String
+
+        def visibility: () -> String
+
+        def tombstones: () -> Set[String]
+      end
+
+      TOMBSTONE_FILE: String
+      CONTENT_PREFIX: String
+
+      attr_reader package_path: String
+      attr_reader layers: Array[Layer]
+      attr_reader dependency_views: Array[[String, MergedView]]
+
+      def initialize: (String package_path, storage: Storage storage,
+                       manifest: Manifest manifest,
+                       ?dependency_views: Array[[String, MergedView]] dependency_views,
+                       ?exported_only: bool exported_only,
+                       ?extra_layers: Array[Layer] extra_layers) -> void
+
+      # The absolute filesystem path serving a resource reference: a
+      # package-relative content path ("content/app.js"), or a dependency
+      # reference ("<dependency-guid>/content/app.js"). nil when no layer
+      # provides the path or it is tombstoned. Non-content paths never
+      # resolve through the view.
+      def resolve: (String? reference) -> String?
+
+      # The [GUID, view] pair whose GUID prefixes the reference (longest
+      # GUID first, so nested GUIDs address the innermost dependency).
+      def dependency_pair_for: (String reference) -> [String, MergedView]?
+    end
+  end
+end

data/sig/capsium/package/metadata.rbs

@@ -21,6 +21,7 @@ module Capsium
       def license: () -> String?
       def repository: () -> Repository?
       def dependencies: () -> Hash[String, String]
+      def read_only: () -> bool?
     end
   end
 end

data/sig/capsium/package/open_pgp.rbs

@@ -0,0 +1,38 @@
+module Capsium
+  class Package
+    # OpenPGP support (signatures and encryption) through the rnp gem's
+    # binding to librnp. rnp is a soft dependency: it is only required
+    # when an OpenPGP feature is used, and this module is the single
+    # place that loads it.
+    module OpenPgp
+      # The rnp gem or the librnp shared library is not available.
+      class OpenPgpUnavailableError < Capsium::Error
+      end
+
+      # A key file is unreadable or holds no suitable OpenPGP key.
+      class KeyError < Capsium::Error
+      end
+
+      UNAVAILABLE_MESSAGE: String
+
+      # One loaded key file: the Rnp context holding the key material
+      # and the selected key within it.
+      class LoadedKey
+        def self.new: (untyped rnp, untyped key) -> void
+
+        def rnp: () -> untyped
+        def key: () -> untyped
+      end
+
+      # A fresh Rnp context. Raises OpenPgpUnavailableError when the rnp
+      # gem or librnp cannot be loaded.
+      def self.rnp: () -> untyped
+
+      # Loads the OpenPGP key at key_path (armored or binary, public or
+      # secret — the format is auto-detected). With secret: true the
+      # selected key must hold secret key material. Raises KeyError when
+      # the file is unreadable or holds no suitable key.
+      def self.load_key: (String key_path, ?secret: bool secret) -> LoadedKey
+    end
+  end
+end

data/sig/capsium/package/open_pgp_cipher.rbs

@@ -0,0 +1,15 @@
+module Capsium
+  class Package
+    # Encrypts and decrypts whole Capsium packages with OpenPGP key
+    # management (ARCHITECTURE.md section 6b) through librnp: the DEK
+    # travels as an armored OpenPGP message in the signature.json
+    # envelope (keyManagement "OpenPGP"); the AES-256-GCM content
+    # encryption and the encrypted .cap layout are the Cipher's.
+    class OpenPgpCipher < Cipher
+      KEY_MANAGEMENT: String
+
+      # The OpenPGP symmetric cipher protecting the DEK message.
+      CIPHER_NAME: String
+    end
+  end
+end

data/sig/capsium/package/open_pgp_signer.rbs

@@ -0,0 +1,46 @@
+module Capsium
+  class Package
+    # Signs and verifies Capsium packages with OpenPGP detached
+    # signatures (ARCHITECTURE.md section 6a) through librnp. Parallel
+    # to the RSA-SHA256/X.509 Signer with the same construction
+    # semantics and the same error taxonomy.
+    class OpenPgpSigner
+      ALGORITHM: String
+      CERTIFICATE_TYPE: String
+      HASH: String
+
+      # Package-relative name of the embedded armored OpenPGP public key
+      # recorded in security.json digitalSignatures.publicKey.
+      PUBLIC_KEY_FILE: String
+
+      attr_reader package_path: String
+
+      def initialize: (String package_path) -> void
+
+      # Signs a package directory in place, or a .cap file (unpacked,
+      # signed, recompressed), with the OpenPGP secret key at
+      # secret_key_path. Returns the signed path.
+      def self.sign_package: (String path, String secret_key_path) -> String
+
+      # Verifies the declared OpenPGP signature of a package directory
+      # or .cap file (false on mismatch; raises typed
+      # Signer::SignatureError subclasses on structural problems).
+      def self.verify_package: (String path, ?String? public_key_path) -> bool
+
+      # Signs the package directory in place: embeds the armored public
+      # key, regenerates security.json (checksums plus digitalSignatures
+      # with certificateType "OpenPGP") and writes the armored detached
+      # OpenPGP signature to signature.sig. Returns the path of the
+      # written signature file.
+      def sign: (String secret_key_path) -> String
+
+      # True when the declared signature verifies against the payload;
+      # false on mismatch.
+      def verify: (?String? public_key_path) -> bool
+
+      def verify!: (?String? public_key_path) -> bool
+
+      def signed?: () -> bool
+    end
+  end
+end

data/sig/capsium/package/preparation.rbs

@@ -0,0 +1,23 @@
+module Capsium
+  class Package
+    # Package-source preparation (ARCHITECTURE.md section 1), mixed into
+    # Package: directory/.cap/encrypted-cap detection, extraction and
+    # decryption into a readable package directory.
+    module Preparation
+      def prepare_package: (Pathname path) -> (String | Pathname)
+
+      def decompress_cap_file: (String | Pathname file_path) -> String
+
+      # Decrypts an encrypted package (.cap file or uncompressed directory)
+      # into a temporary directory and returns its path. Raises
+      # Cipher::KeyRequiredError when no decryption_key was given.
+      def decrypt_cap_file: (String | Pathname source_path) -> String
+
+      def determine_load_type: (String | Pathname path) -> Symbol
+
+      # Whether the package was loaded from an encrypted source
+      # (ARCHITECTURE.md section 6b layout).
+      def encrypted?: () -> bool
+    end
+  end
+end

data/sig/capsium/package/routes_config.rbs

@@ -1,8 +1,22 @@
 module Capsium
   class Package
+    # The "responseRewrite" object of an inherited route (05x-routing
+    # section "Route Inheritance"): replaces the served body and/or
+    # overrides response headers.
+    class ResponseRewrite
+      attr_accessor body: String?
+      attr_accessor headers: Hash[String, String]?
+
+      def initialize: (?body: String? body, ?headers: Hash[String, String]? headers) -> void
+
+      def to_json: (*untyped args) -> String
+      def to_hash: () -> Hash[String, untyped]
+    end
+
     # A single route entry (ARCHITECTURE.md section 4). Kinds are
     # discriminated by key, MECE: static file, dataset route, or dynamic
-    # handler (accepted-and-ignored; reactors respond 501).
+    # handler (accepted-and-ignored; reactors respond 501). Route
+    # inheritance attributes per 05x-routing.
     class Route
       DATASET_PATH_PREFIX: String
 
@@ -15,6 +29,10 @@ module Capsium
       attr_accessor access_control: Hash[String, untyped]?
       attr_accessor http_method: String?
       attr_accessor handler: String?
+      attr_accessor remap: String?
+      attr_accessor response_rewrite: ResponseRewrite?
+      attr_accessor response_headers: Hash[String, String]?
+      attr_accessor request_headers: Hash[String, String]?
 
       def initialize: (?path: String? path, ?resource: String? resource,
                        ?headers: Hash[String, String]? headers,
@@ -22,7 +40,10 @@ module Capsium
                        ?visibility: String? visibility, ?dataset: String? dataset,
                        ?access_control: Hash[String, untyped]? access_control,
                        ?http_method: String? http_method,
-                       ?handler: String? handler) -> void
+                       ?handler: String? handler, ?remap: String? remap,
+                       ?response_rewrite: ResponseRewrite? response_rewrite,
+                       ?response_headers: Hash[String, String]? response_headers,
+                       ?request_headers: Hash[String, String]? request_headers) -> void
 
       def self.from_json: (String json) -> instance
 
@@ -32,11 +53,23 @@ module Capsium
 
       def handler_route?: () -> bool
 
+      # The URL path this route answers at: the remapped path when the
+      # route remaps an inherited route, its own path otherwise.
+      def serving_path: () -> String?
+
+      # Whether the resource addresses content of a dependency package
+      # ("<dependency-guid>/<path>" — a URI rather than a
+      # package-relative path).
+      def dependency_reference?: () -> bool
+
+      # Whether the route carries route-inheritance attributes.
+      def inherited?: () -> bool
+
       def fs_path: (String package_path) -> String?
 
       def mime: (Manifest manifest) -> String?
 
-      def validate_target: (String package_path, Storage storage) -> void
+      def validate_target: (String package_path, Storage storage, ?merged_view: MergedView? merged_view) -> void
 
       def to_json: (*untyped args) -> String
       def to_hash: () -> Hash[String, untyped]

data/sig/capsium/package/security.rbs

@@ -2,7 +2,7 @@ module Capsium
   class Package
     # Loads, generates and verifies security.json (ARCHITECTURE.md
     # section 6). Checksums cover every file in the package except
-    # security.json itself.
+    # security.json itself and signature.sig.
     class Security
       class IntegrityError < Capsium::Error
       end
@@ -42,14 +42,21 @@ module Capsium
 
       def initialize: (String path, ?SecurityConfig? config) -> void
 
-      def self.generate: (String package_path) -> Security
+      def self.generate: (String package_path, ?digital_signatures: DigitalSignatures? digital_signatures) -> Security
 
       def self.checksums_for: (String package_path) -> Hash[String, String]
 
       def self.package_files: (String package_path) -> Array[String]
 
+      def self.excluded?: (String relative_path) -> bool
+
       def present?: () -> bool
 
+      # The declared digitalSignatures block, or nil when absent.
+      def digital_signatures: () -> DigitalSignatures?
+
+      def signed?: () -> bool
+
       def checksums: () -> Hash[String, String]
 
       def verify: (String package_path) -> Array[ChecksumMismatch | MissingFile | UncheckedFile]

data/sig/capsium/package/security_config.rbs

@@ -15,13 +15,16 @@ module Capsium
       def to_hash: () -> Hash[String, untyped]
     end
 
-    # The "digitalSignatures" object of security.json (parsed only;
-    # signing is a later phase).
+    # The "digitalSignatures" object of security.json: certificateType
+    # selects the signature scheme (absent = RSA-SHA256/X.509,
+    # "OpenPGP" = OpenPGP).
     class DigitalSignatures
+      attr_accessor certificate_type: String?
       attr_accessor public_key: String?
       attr_accessor signature_file: String?
 
-      def initialize: (?public_key: String? public_key,
+      def initialize: (?certificate_type: String? certificate_type,
+                       ?public_key: String? public_key,
                        ?signature_file: String? signature_file) -> void
 
       def to_json: (*untyped args) -> String