k9o 1.0.0

data/lib/k9o/migrations.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module K9o
+  # Migration lifecycle namespace — k9o.migrations.*.
+  #
+  # TYPE MODEL (ch13 §2.2, cemented f21b3c15 — Ruby is TIER-3):
+  #
+  #   Ruby keeps a RUNTIME HASH PASS-THROUGH for migration payloads (the
+  #   gateway is the fail-closed source of truth; SDK types are ergonomics +
+  #   serialization, never validation). The structured shape is documented
+  #   below AND statically checkable via the shipped RBS signatures in
+  #   sig/k9o/migrations.rbs (steep/typeprof), per the tier-3 contract:
+  #   "documented + statically-checkable pass-through".
+  #
+  #   The control-plane request/submit shape (the +migrations+ array) is the
+  #   FIXED migration Operation union — control-plane, so it is TYPED. Build
+  #   well-formed operation hashes with the keyword-arg helpers on
+  #   K9o::Migrations::Build (idiomatic Ruby "typed" constructors) which emit
+  #   exactly the wire JSON; or hand-author the hash against the documented
+  #   shape. The closed-union property (exactly these 7 ops) is enforced at
+  #   wire + server validation for all tiers.
+  #
+  # WIRE SHAPE (snake_case keys, matches packages/core/src/migrations.ts):
+  #
+  #   migration = {
+  #     'version' => Integer,           # NOTE: integer, not a "001" string
+  #     'slug'    => String,
+  #     'up'      => [Operation, ...],
+  #     'down'    => [Operation, ...],
+  #     'policy'  => MigrationPolicy,   # optional
+  #   }
+  #
+  #   Operation — KEY-TAGGED union, EXACTLY ONE key, one of these 7 (alter_table
+  #   is the batched column mutation, live in the gateway runner; rename_column
+  #   remains a pending future op, intentionally absent):
+  #     { 'create_table' => { 'name' => String,
+  #                           'columns' => [ColumnSpec, ...],
+  #                           'indexes' => [IndexSpec, ...] } }   # indexes optional
+  #     { 'drop_table'   => String }
+  #     { 'add_column'   => { 'table' => String, 'column' => ColumnSpec } }
+  #     { 'drop_column'  => { 'table' => String, 'column' => String } }
+  #     { 'create_index' => { 'table' => String, 'index' => IndexSpec } }
+  #     { 'drop_index'   => { 'name'  => String } }
+  #
+  #   ColumnSpec = {
+  #     'name'          => String,
+  #     'type'          => String,      # parser-owned vocabulary; NOT an enum
+  #     'primary_key'   => true|false,  # optional
+  #     'not_null'      => true|false,  # optional
+  #     'unique'        => true|false,  # optional
+  #     'default'       => String,      # optional
+  #     'references'    => ColumnReferences, # optional
+  #     'encrypted'     => true | { 'store' => 'inline'|'vault',
+  #                                 'searchable' => true|false },  # optional
+  #                       # NOTE: 'searchable' is NESTED inside the object form,
+  #                       # NOT a sibling of the column.
+  #     'blind_indexed' => true|false,  # optional (C-mode equality lookup)
+  #   }
+  #
+  #   IndexSpec        = { 'name' => String (optional), 'columns' => [String, ...],
+  #                        'unique' => true|false (optional) }
+  #   ColumnReferences = { 'collection' => String, 'on' => String,
+  #                        'on_delete' => 'CASCADE'|'RESTRICT'|'SET NULL'|'NO ACTION' (opt),
+  #                        'on_update' => same (opt) }
+  #
+  #   MigrationPolicy  = { 'collections' => { String => CollectionPolicy },
+  #                        'storage' => { 'buckets' => { String => StorageBucketPolicy } } }
+  #   CollectionPolicy = { 'references' => [RelationshipSpec, ...],
+  #                        'actions' => { 'select'|'insert'|'update'|'delete' => ActionRule } }
+  #   RelationshipSpec = { 'collection' => String, 'on' => String, 'as' => String,
+  #                        'type' => 'inner'|'left' (opt) }
+  #   ActionRule       = { 'rule' => any (opt) }
+  #   StorageBucketPolicy = { 'public' => true|false (opt),
+  #                           'actions' => { 'read'|'upload'|'delete'|'list' => ActionRule } }
+  #
+  # RESPONSE records (returned in the envelope data, pass-through hashes):
+  #   AppliedMigration = { 'version' => Integer, 'slug' => String,
+  #                        'checksum' => String, 'appliedAt' => String }
+  #   PendingMigration = { 'pendingId' => String, 'version' => Integer,
+  #                        'slug' => String, 'checksum' => String,
+  #                        'submittedAt' => String, 'submittedBy' => String }
+  class Migrations
+    def initialize(config)
+      @config = config
+    end
+
+    # Apply migrations immediately (PROJECT_ADMIN minimum).
+    # +migrations+ is an array of migration hashes (see the shape above; build
+    # operation hashes with K9o::Migrations::Build).
+    def apply(migrations)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'POST',
+                            path: UrlGrammar.project_path(slug, 'migrations/apply'), body: { 'migrations' => migrations })
+    end
+
+    def list
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.project_path(slug, 'migrations'))
+    end
+
+    def get(version)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'GET',
+                            path: UrlGrammar.project_path(slug, "migrations/#{enc(version)}"))
+    end
+
+    # Queue migrations for maker-checker approval per ch06 §8.
+    def queue(migrations)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'POST',
+                            path: UrlGrammar.project_path(slug, 'migrations/queue'), body: { 'migrations' => migrations })
+    end
+
+    def list_pending
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.project_path(slug, 'migrations/pending'))
+    end
+
+    def apply_pending(pending_id)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'POST',
+                            path: UrlGrammar.project_path(slug, "migrations/pending/#{enc(pending_id)}/apply"))
+    end
+
+    def reject_pending(pending_id, reason: nil)
+      slug = require_project_slug
+      body = reason ? { 'reason' => reason } : nil
+      HttpTransport.request(config: @config, method: 'POST',
+                            path: UrlGrammar.project_path(slug, "migrations/pending/#{enc(pending_id)}/reject"), body: body)
+    end
+
+    def delete_pending(pending_id)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'DELETE',
+                            path: UrlGrammar.project_path(slug, "migrations/pending/#{enc(pending_id)}"))
+    end
+
+    # Typed keyword-arg constructors for the FIXED control-plane migration
+    # Operation union + its sub-shapes. Each returns the exact wire hash; nil
+    # keyword args are omitted so the emitted JSON matches the canonical
+    # `omitempty`/optional shape (packages/core/src/migrations.ts,
+    # packages/go/migrations.go). These are the tier-3 "typed request object"
+    # surface — the RBS in sig/k9o/migrations.rbs gives them static checking.
+    module Build
+      module_function
+
+      # --- ColumnSpec --------------------------------------------------------
+      # +encrypted+: pass `true` for the inline shorthand, or the object hash
+      # `{ 'store' => 'inline'|'vault', 'searchable' => bool }`. Prefer the
+      # column_encryption helper to build the object form correctly (searchable
+      # NESTED, never a sibling).
+      def column(name:, type:, primary_key: nil, not_null: nil, unique: nil,
+                 default: nil, references: nil, encrypted: nil, blind_indexed: nil)
+        h = { 'name' => name, 'type' => type }
+        h['primary_key']   = primary_key   unless primary_key.nil?
+        h['not_null']      = not_null       unless not_null.nil?
+        h['unique']        = unique         unless unique.nil?
+        h['default']       = default        unless default.nil?
+        h['references']    = references     unless references.nil?
+        h['encrypted']     = encrypted      unless encrypted.nil?
+        h['blind_indexed'] = blind_indexed  unless blind_indexed.nil?
+        h
+      end
+
+      # Object form of the `encrypted` union. The bare `true` shorthand needs no
+      # helper — just pass `encrypted: true`. Here +searchable+ is NESTED inside
+      # the returned object, per the cemented shape.
+      def column_encryption(store:, searchable: nil)
+        h = { 'store' => store }
+        h['searchable'] = searchable unless searchable.nil?
+        h
+      end
+
+      def references(collection:, on:, on_delete: nil, on_update: nil)
+        h = { 'collection' => collection, 'on' => on }
+        h['on_delete'] = on_delete unless on_delete.nil?
+        h['on_update'] = on_update unless on_update.nil?
+        h
+      end
+
+      def index(columns:, name: nil, unique: nil)
+        h = { 'columns' => columns }
+        h['name']   = name   unless name.nil?
+        h['unique'] = unique unless unique.nil?
+        h
+      end
+
+      # --- Operation union (exactly one key per op) --------------------------
+      def create_table(name:, columns:, indexes: nil)
+        op = { 'name' => name, 'columns' => columns }
+        op['indexes'] = indexes unless indexes.nil?
+        { 'create_table' => op }
+      end
+
+      def drop_table(name)
+        { 'drop_table' => name }
+      end
+
+      def add_column(table:, column:)
+        { 'add_column' => { 'table' => table, 'column' => column } }
+      end
+
+      def drop_column(table:, column:)
+        { 'drop_column' => { 'table' => table, 'column' => column } }
+      end
+
+      # alter_table — BATCHED column mutation: one op carries optional
+      # add_columns + drop_columns (not separate ops). add_columns entries are
+      # full column_spec; drop_columns is column names. Live in the gateway
+      # runner.
+      def alter_table(name:, add_columns: nil, drop_columns: nil)
+        op = { 'name' => name }
+        op['add_columns'] = add_columns unless add_columns.nil?
+        op['drop_columns'] = drop_columns unless drop_columns.nil?
+        { 'alter_table' => op }
+      end
+
+      def create_index(table:, index:)
+        { 'create_index' => { 'table' => table, 'index' => index } }
+      end
+
+      def drop_index(name:)
+        { 'drop_index' => { 'name' => name } }
+      end
+
+      # --- Migration ---------------------------------------------------------
+      def migration(version:, slug:, up:, down:, policy: nil)
+        h = { 'version' => version, 'slug' => slug, 'up' => up, 'down' => down }
+        h['policy'] = policy unless policy.nil?
+        h
+      end
+    end
+
+    private
+
+    def require_project_slug
+      Studio.require_project_slug(@config, 'migrations')
+    end
+
+    def enc(s)
+      ::URI.encode_www_form_component(s)
+    end
+  end
+end

data/lib/k9o/multipart.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module K9o
+  # Minimal multipart/form-data encoder (stdlib only). Parts are hashes:
+  #   { name: 'path', value: 'a.txt' }                       # plain field
+  #   { name: 'file', value: bytes, filename: 'a.txt',        # file part
+  #     content_type: 'text/plain' }
+  # Values are sent as given, byte for byte (a String is its own bytes).
+  module Multipart
+    module_function
+
+    # Returns [body (binary String), content_type header value].
+    def encode(parts)
+      payload = parts.map { |p| p[:value].to_s.b }
+      boundary = nil
+      loop do
+        boundary = "----k9o-#{SecureRandom.hex(16)}"
+        break unless payload.any? { |v| v.include?(boundary) }
+      end
+
+      body = String.new(encoding: Encoding::BINARY)
+      parts.each_with_index do |p, i|
+        disposition = %(form-data; name="#{escape(p[:name])}")
+        disposition += %(; filename="#{escape(p[:filename])}") if p[:filename]
+        body << "--#{boundary}\r\n".b
+        body << "Content-Disposition: #{disposition}\r\n".b
+        body << "Content-Type: #{p[:content_type]}\r\n".b if p[:content_type]
+        body << "\r\n".b
+        body << payload[i]
+        body << "\r\n".b
+      end
+      body << "--#{boundary}--\r\n".b
+      [body, "multipart/form-data; boundary=#{boundary}"]
+    end
+
+    def escape(value)
+      value.to_s.gsub('"', '%22').gsub("\r", '%0D').gsub("\n", '%0A')
+    end
+  end
+end

data/lib/k9o/org.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module K9o
+  # Org-plane bound namespace — k9o.org.*. Singular
+  # bound-org namespace (distinct from k9o.orgs collection): members /
+  # groups / smtp / audit_log / gate (roles + idp_providers) + default_llm.
+  # Org-plane URL grammar per v2.5.68 §5.4 routes against the org subdomain
+  # without the @<projectSlug>/ prefix.
+  class Org
+    attr_reader :members, :groups, :smtp, :audit_log, :gate, :default_llm
+
+    def initialize(config)
+      @config = config
+      @members = Members.new(config)
+      @groups = Groups.new(config)
+      @smtp = Smtp.new(config)
+      @audit_log = AuditLog.new(config)
+      @gate = Gate.new(config)
+      @default_llm = DefaultLlm.new(config)
+    end
+
+    # Read the current org (slug + name + status + settings).
+    def get
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('org'))
+    end
+
+    def self.enc(str)
+      ::URI.encode_www_form_component(str)
+    end
+
+    # k9o.org.members.*
+    class Members
+      def initialize(config)
+        @config = config
+      end
+
+      def list(status: nil)
+        q = status ? { 'status' => status } : nil
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('members'), query: q)
+      end
+
+      def invite(email:, role:)
+        HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path('members'),
+                              body: { 'email' => email, 'role' => role })
+      end
+
+      def get(user_id)
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path("members/#{Org.enc(user_id)}"))
+      end
+
+      def remove(user_id)
+        HttpTransport.request(config: @config, method: 'DELETE', path: UrlGrammar.org_path("members/#{Org.enc(user_id)}"))
+      end
+    end
+
+    # k9o.org.groups.*
+    class Groups
+      def initialize(config)
+        @config = config
+      end
+
+      def list
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('groups'))
+      end
+
+      def create(name:)
+        HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path('groups'), body: { 'name' => name })
+      end
+
+      def get(group_id)
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path("groups/#{Org.enc(group_id)}"))
+      end
+
+      def delete(group_id)
+        HttpTransport.request(config: @config, method: 'DELETE', path: UrlGrammar.org_path("groups/#{Org.enc(group_id)}"))
+      end
+    end
+
+    # k9o.org.audit_log.* (org-plane; distinct from project Audit).
+    class AuditLog
+      def initialize(config)
+        @config = config
+      end
+
+      def query(since: nil, until_: nil, type: nil, actor_id: nil, target_kind: nil, target_id: nil, limit: nil, cursor: nil)
+        q = {}
+        q['since'] = since if since
+        q['until'] = until_ if until_
+        q['type'] = type if type
+        q['actorId'] = actor_id if actor_id
+        q['targetKind'] = target_kind if target_kind
+        q['targetId'] = target_id if target_id
+        q['limit'] = limit if limit
+        q['cursor'] = cursor if cursor
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('audit-log'), query: q)
+      end
+    end
+
+    # k9o.org.gate.*
+    class Gate
+      attr_reader :roles, :idp_providers
+
+      def initialize(config)
+        @roles = Roles.new(config)
+        @idp_providers = IdpProviders.new(config)
+      end
+
+      # k9o.org.gate.roles.*
+      class Roles
+        def initialize(config)
+          @config = config
+        end
+
+        def list(user_id: nil, role: nil)
+          q = {}
+          q['userId'] = user_id if user_id
+          q['role'] = role if role
+          HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('org-role-grants'), query: q)
+        end
+
+        def grant(user_id:, role:)
+          HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path('org-role-grants'),
+                                body: { 'userId' => user_id, 'role' => role })
+        end
+
+        def get(grant_id)
+          HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path("org-role-grants/#{Org.enc(grant_id)}"))
+        end
+
+        def revoke(grant_id)
+          HttpTransport.request(config: @config, method: 'DELETE', path: UrlGrammar.org_path("org-role-grants/#{Org.enc(grant_id)}"))
+        end
+      end
+
+      # k9o.org.gate.idp_providers.*
+      class IdpProviders
+        def initialize(config)
+          @config = config
+        end
+
+        def list
+          HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('idp-providers'))
+        end
+
+        def create(name:, kind:, config:)
+          HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path('idp-providers'),
+                                body: { 'name' => name, 'kind' => kind, 'config' => config })
+        end
+
+        def get(idp_id)
+          HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path("idp-providers/#{Org.enc(idp_id)}"))
+        end
+
+        def configure(idp_id, patch)
+          HttpTransport.request(config: @config, method: 'PATCH',
+                                path: UrlGrammar.org_path("idp-providers/#{Org.enc(idp_id)}"), body: patch)
+        end
+
+        def delete(idp_id)
+          HttpTransport.request(config: @config, method: 'DELETE', path: UrlGrammar.org_path("idp-providers/#{Org.enc(idp_id)}"))
+        end
+      end
+    end
+
+    # k9o.org.smtp.*
+    class Smtp
+      def initialize(config)
+        @config = config
+      end
+
+      def get
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('org/smtp'))
+      end
+
+      def set(host:, port:, username:, password:, from_email:, from_name:, encryption:, reply_to_email: nil)
+        smtp = {
+          'host' => host, 'port' => port, 'username' => username, 'password' => password,
+          'fromEmail' => from_email, 'fromName' => from_name, 'encryption' => encryption
+        }
+        smtp['replyToEmail'] = reply_to_email if reply_to_email
+        HttpTransport.request(config: @config, method: 'PATCH', path: UrlGrammar.org_path('org'), body: { 'smtpConfig' => smtp })
+      end
+
+      def test(to:, from_override: nil)
+        body = { 'to' => to }
+        body['fromOverride'] = from_override if from_override
+        HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path('org/smtp/test-email'), body: body)
+      end
+
+      def unset
+        HttpTransport.request(config: @config, method: 'PATCH', path: UrlGrammar.org_path('org'), body: { 'smtpConfig' => nil })
+      end
+    end
+
+    # k9o.org.default_llm.* per ch07 §10.3 (ORG_ADMIN; tier-gated).
+    class DefaultLlm
+      def initialize(config)
+        @config = config
+      end
+
+      # Read the org-default LLM model id (nil when unset → mistral-7b).
+      def get
+        HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('org/default-llm'))
+      end
+
+      # Set the org-default LLM (ORG_ADMIN; tier-gated per §10.1).
+      def set(model_id)
+        HttpTransport.request(config: @config, method: 'PATCH',
+                              path: UrlGrammar.org_path('org/default-llm'), body: { 'modelId' => model_id })
+      end
+    end
+  end
+end

data/lib/k9o/orgs.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module K9o
+  # Org lifecycle namespace (collection-style) — k9o.orgs.*.
+  # Distinct from k9o.org (singular bound-org namespace).
+  class Orgs
+    def initialize(config)
+      @config = config
+    end
+
+    def list
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('orgs'))
+    end
+
+    def get(org_slug)
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path("orgs/#{enc(org_slug)}"))
+    end
+
+    def restore(org_id)
+      HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path("orgs/#{enc(org_id)}/restore"))
+    end
+
+    def current
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('org'))
+    end
+
+    private
+
+    def enc(s)
+      ::URI.encode_www_form_component(s)
+    end
+  end
+end

data/lib/k9o/policies.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module K9o
+  # Policy bundle lifecycle namespace — k9o.policies.*.
+  class Policies
+    def initialize(config)
+      @config = config
+    end
+
+    def current
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.project_path(slug, 'policy'))
+    end
+
+    def list(status: nil)
+      slug = require_project_slug
+      q = status ? { 'status' => status } : nil
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.project_path(slug, 'policies'), query: q)
+    end
+
+    def create(name:, rules:)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.project_path(slug, 'policies'),
+                            body: { 'name' => name, 'rules' => rules })
+    end
+
+    def validate(rules)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.project_path(slug, 'policies/validate'),
+                            body: { 'rules' => rules })
+    end
+
+    def get(bundle_id)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.project_path(slug, "policies/#{enc(bundle_id)}"))
+    end
+
+    def update(bundle_id, patch)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'PATCH',
+                            path: UrlGrammar.project_path(slug, "policies/#{enc(bundle_id)}"), body: patch)
+    end
+
+    def delete(bundle_id)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'DELETE', path: UrlGrammar.project_path(slug, "policies/#{enc(bundle_id)}"))
+    end
+
+    def publish(bundle_id)
+      slug = require_project_slug
+      HttpTransport.request(config: @config, method: 'POST',
+                            path: UrlGrammar.project_path(slug, "policies/#{enc(bundle_id)}/publish"))
+    end
+
+    private
+
+    def require_project_slug
+      Studio.require_project_slug(@config, 'policies')
+    end
+
+    def enc(s)
+      ::URI.encode_www_form_component(s)
+    end
+  end
+end

data/lib/k9o/projects.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module K9o
+  # Project lifecycle namespace — k9o.projects.* (Ruby snake_case).
+  class Projects
+    def initialize(config)
+      @config = config
+    end
+
+    def list
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.org_path('projects'))
+    end
+
+    def create(slug:, name:, custody_mode: nil)
+      UrlGrammar.validate_slug(slug, 'project')
+      body = { 'slug' => slug, 'name' => name }
+      body['custodyMode'] = custody_mode if custody_mode
+      HttpTransport.request(config: @config, method: 'POST', path: UrlGrammar.org_path('projects'), body: body)
+    end
+
+    def get(slug)
+      UrlGrammar.validate_slug(slug, 'project')
+      HttpTransport.request(config: @config, method: 'GET', path: UrlGrammar.project_path(slug, 'project'))
+    end
+
+    def update(slug, name: nil)
+      UrlGrammar.validate_slug(slug, 'project')
+      patch = {}
+      patch['name'] = name if name
+      HttpTransport.request(config: @config, method: 'PATCH', path: UrlGrammar.project_path(slug, 'project'), body: patch)
+    end
+  end
+end