ecoportal-api-graphql 2.2.0 → 3.0.0

data/lib/ecoportal/api/graphql/model/template/staged_executor.rb

@@ -0,0 +1,236 @@
+require 'securerandom'
+
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Ports a downstream script repo's staged `-template-force-install` install (sections ->
+          # re-read -> fields+options -> re-read -> forces -> re-read -> helpers+bindings) into
+          # a GENERIC, four-phase executor that works for ANY `Instance`, any number of
+          # stages/sections/fields — not one template's shape. Each phase is built FRESH from
+          # the CURRENT tree (`CommandSynthesis`'s phase-scoped methods), so a node resolved by
+          # an earlier phase (`Node#resolve!`) is addressed by its real id — never its stale
+          # placeholder — the moment the next phase's commands are synthesised (`Node#ref`
+          # itself does the upgrade; nothing here has to rewrite a command hash by hand).
+          #
+          # Sends through `Builder::Template#update` (`updatePageTemplate`) — NEVER
+          # `executeWorkflowCommands` — per `18_template_editor_save_path.md` section D.4/B.3's
+          # own recommendation (the SAME safety invariants the template editor enforces should
+          # apply to bulk/automated writes). Every call carries a fresh `clientMutationId` for
+          # tracing/correlation ONLY — the server does NOT dedupe on it (confirmed: neither
+          # `UpdateForm` nor `ExecuteCommandsForm` reference it in
+          # `18_template_editor_save_path.md` section B).
+          class StagedExecutor
+            DEFAULT_CHUNK_SIZE = 200
+
+            PHASES = %i[stage_phase section_phase field_phase force_phase helper_binding_phase].freeze
+
+            # Placeholder prefixes that MUST already be resolved to real ids by the time this
+            # phase's commands are built — a leftover token here means an earlier phase's
+            # resolution silently failed to cover this node, and sending anyway would either
+            # get rejected server-side or (worse) silently misfire. See `#guard_resolved!`.
+            REQUIRES_RESOLVED = {
+              section_phase:        %w[stg],
+              field_phase:          %w[stg sec],
+              force_phase:          %w[stg],
+              helper_binding_phase: %w[stg sec frc fld]
+            }.freeze
+
+            Plan   = Struct.new(:stages, keyword_init: true)
+            Result = Struct.new(:ok, :patch_ver, :stages, :error, keyword_init: true)
+
+            def initialize(instance, client:, chunk_size: DEFAULT_CHUNK_SIZE)
+              @instance   = instance
+              @client     = client
+              @chunk_size = chunk_size
+            end
+
+            # SIMULATE — no call is made. Returns the plan every phase WOULD send: command
+            # counts, chunk sizes, and every placeholder token appearing in that phase (a
+            # caller can eyeball this before ever touching the server).
+            def plan
+              synth = CommandSynthesis.new(instance)
+              Plan.new(stages: PHASES.map { |phase| phase_plan(synth, phase) })
+            end
+
+            # EXECUTE — actually sends the staged batches. Raises ArgumentError up front if no
+            # client was given (a `simulate: false` call with no client is a caller mistake,
+            # not a runtime condition to swallow).
+            def execute!
+              raise ArgumentError, 'StagedExecutor#execute! requires a client (got nil)' if client.nil?
+
+              patch_ver = instance.patch_ver
+              report = []
+
+              PHASES.each do |phase|
+                outcome = execute_phase(phase, patch_ver)
+                report << outcome
+                return abort(report, outcome[:error]) unless outcome[:ok]
+
+                patch_ver = outcome[:patch_ver]
+              end
+
+              Result.new(ok: true, patch_ver: patch_ver, stages: report, error: nil)
+            end
+
+            private
+
+            attr_reader :instance, :client, :chunk_size
+
+            def phase_plan(synth, phase)
+              commands = synth.public_send(phase)
+              chunks   = CommandGrouper.chunk(commands, chunk_size)
+              { phase: phase, command_count: commands.size, chunk_sizes: chunks.map(&:size),
+                placeholders: CommandGrouper.tokens_in(commands) }
+            end
+
+            def execute_phase(phase, patch_ver)
+              commands = CommandSynthesis.new(instance).public_send(phase)
+              return { phase: phase, ok: true, patch_ver: patch_ver, sent: 0 } if commands.empty?
+
+              guard_resolved!(phase, commands)
+
+              chunks = CommandGrouper.chunk(commands, chunk_size)
+              chunks.each do |chunk|
+                response = send_chunk(chunk, patch_ver)
+                return { phase: phase, ok: false, patch_ver: patch_ver, error: response[:error] } unless response[:ok]
+
+                patch_ver = response[:patch_ver]
+              end
+
+              resolve_phase!(phase)
+              { phase: phase, ok: true, patch_ver: patch_ver, sent: commands.size }
+            end
+
+            def abort(report, error)
+              Result.new(ok: false, patch_ver: report.last[:patch_ver], stages: report, error: error)
+            end
+
+            # Refuses to send a batch that still references a placeholder an EARLIER phase
+            # should already have resolved — see `REQUIRES_RESOLVED`'s own doc.
+            def guard_resolved!(phase, commands)
+              prefixes = REQUIRES_RESOLVED[phase]
+              return if prefixes.nil? || prefixes.empty?
+
+              stale = CommandGrouper.tokens_in(commands).select { |tok| prefixes.any? { |p| tok.start_with?("ph_#{p}_") } }
+              return if stale.empty?
+
+              raise "StagedExecutor: refusing to send #{phase} — it still references " \
+                    "#{stale.size} unresolved placeholder(s) from an earlier phase: #{stale.join(', ')}. " \
+                    'An earlier phase\'s resolution step did not cover every new node it created.'
+            end
+
+            def send_chunk(chunk, patch_ver)
+              payload = builder.update(instance, commands: chunk, patch_ver: patch_ver,
+                                                  client_mutation_id: "tmpl-model-#{SecureRandom.hex(6)}")
+              return { ok: false, error: 'no payload returned' } if payload.nil?
+              return { ok: false, error: payload.error_doc } if payload.error?
+
+              { ok: true, patch_ver: payload.item.patchVer }
+            end
+
+            def builder
+              @builder ||= client.template
+            end
+
+            # --- between-phase resolution -------------------------------------------
+
+            def resolve_phase!(phase)
+              case phase
+              when :stage_phase then resolve_stages! if instance.stages.any?(&:new?)
+              when :section_phase then resolve_sections! if instance.sections.any?(&:new?)
+              when :field_phase then resolve_fields! if instance.fields.any?(&:new?)
+              when :force_phase then resolve_forces! if instance.forces.any?(&:new?)
+              end
+            end
+
+            def fresh_page
+              Read.call(client, instance.id)
+            end
+
+            def resolve_stages!
+              live = Read.stages(fresh_page)
+              resolve_new_children!(instance.stages, live, cross_check: :name, live_key: 'name', label: 'stage')
+            end
+
+            def resolve_sections!
+              live_stages = Read.stages(fresh_page)
+              instance.stages.each_with_index do |stage, i|
+                live_sections = Array(live_stages.dig(i, 'sections'))
+                resolve_new_children!(stage.sections, live_sections, cross_check: :heading, live_key: 'heading', label: "stage[#{i}] section")
+              end
+            end
+
+            def resolve_fields!
+              live_stages = Read.stages(fresh_page)
+              instance.stages.each_with_index do |stage, si|
+                stage.sections.each_with_index do |section, sci|
+                  live_section = live_stages.dig(si, 'sections', sci)
+                  resolve_section_fields!(section, live_section)
+                end
+              end
+            end
+
+            def resolve_section_fields!(section, live_section)
+              if section.kind == :split
+                resolve_new_children!(section.left_fields, Array(live_section&.dig('leftDataFields')),
+                                      cross_check: :label, live_key: 'label', label: 'split left field')
+                resolve_new_children!(section.right_fields, Array(live_section&.dig('rightDataFields')),
+                                      cross_check: :label, live_key: 'label', label: 'split right field')
+              else
+                resolve_new_children!(section.left_fields, Array(live_section&.dig('dataFields')),
+                                      cross_check: :label, live_key: 'label', label: 'content field')
+              end
+            end
+
+            def resolve_forces!
+              live_stages = Read.stages(fresh_page)
+              instance.stages.each_with_index do |stage, i|
+                live_forces = Array(live_stages.dig(i, 'forces'))
+                resolve_new_children!(stage.forces, live_forces, cross_check: :name, live_key: 'name', label: "stage[#{i}] force")
+              end
+            end
+
+            # Generic positional-plus-cross-check resolver: `nodes` is the CURRENT in-memory
+            # sibling list (loaded ones keep their relative order; new ones are appended, so
+            # `nodes.select(&:new?)` is exactly "the ones the last-sent batch just created, in
+            # creation order"). `live_docs` is the FRESH re-read of the SAME sibling collection.
+            #
+            #   count guard  — live count minus the pre-existing count must equal exactly the
+            #                  number of new nodes this batch created (never "roughly matches").
+            #   cross-check  — the new server docs are assumed appended at the tail, matched
+            #                  1:1 in creation order; when the node's own `cross_check`
+            #                  attribute is non-nil, it must equal the live doc's `live_key`
+            #                  value, or resolution raises rather than silently mis-mapping an
+            #                  id to the wrong node.
+            def resolve_new_children!(nodes, live_docs, cross_check:, live_key:, label:)
+              new_nodes = nodes.select(&:new?)
+              return if new_nodes.empty?
+
+              before_count = nodes.size - new_nodes.size
+              delta        = live_docs.size - before_count
+              if delta != new_nodes.size
+                raise "StagedExecutor: #{label} count guard failed -- expected #{new_nodes.size} new, " \
+                      "live delta is #{delta} (before=#{before_count}, live=#{live_docs.size})"
+              end
+
+              matched = live_docs.last(delta)
+              new_nodes.each_with_index do |node, idx|
+                live     = matched[idx]
+                expected = node.public_send(cross_check)
+                actual   = live[live_key]
+                if !expected.nil? && expected != actual
+                  raise "StagedExecutor: #{label} cross-check failed at position #{idx} -- " \
+                        "expected #{cross_check}=#{expected.inspect}, live #{live_key}=#{actual.inspect}"
+                end
+
+                node.resolve!(live['id'])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template.rb

@@ -5,12 +5,45 @@ module Ecoportal
         # Concrete counterparts of `Base::Template::*` (see there for the page-vs-Template
         # type asymmetry). `Information` and `RelatedPages` need no extra wiring — both are
         # flat, read-only models; `ChangeLogEntry` adds the `owner` embed.
+        #
+        # This module ALSO carries the mutable, editable template model
+        # (the repo's internal docs) — "the three
+        # lines":
+        #
+        #   template = Ecoportal::API::GraphQL::Model::Template.load(api, id: page_id)
+        #   template.fields.each { |f| f.label = "#{f.label} (reviewed)" }
+        #   template.save!(api)
+        #
+        # `Instance` is the class `.load` returns; `.load` is the ergonomic module-level entry
+        # point so callers never have to spell `Instance` themselves.
         module Template
           class Information < Base::Template::Information; end
 
           class RelatedPages < Base::Template::RelatedPages; end
 
           require_relative 'template/change_log_entry'
+
+          require_relative 'template/node'
+          require_relative 'template/option'
+          require_relative 'template/binding'
+          require_relative 'template/helper'
+          require_relative 'template/field'
+          require_relative 'template/section'
+          require_relative 'template/force'
+          require_relative 'template/stage'
+          require_relative 'template/read'
+          require_relative 'template/command_synthesis'
+          require_relative 'template/command_normalizer'
+          require_relative 'template/command_grouper'
+          require_relative 'template/staged_executor'
+          require_relative 'template/instance'
+
+          # @param client [Ecoportal::API::GraphQL] the top-level gem client.
+          # @param id [String] the template's page id.
+          # @return [Instance]
+          def self.load(client, id:)
+            Instance.load(client, id: id)
+          end
         end
       end
     end

data/lib/ecoportal/api/graphql/model.rb

@@ -14,6 +14,7 @@ require_relative 'model/user'
 require_relative 'model/person_member'
 require_relative 'model/file_attachment'
 require_relative 'model/file_container'
+require_relative 'model/temp_image'
 require_relative 'model/field'
 require_relative 'model/page'
 require_relative 'model/page_union'

data/lib/ecoportal/api/graphql/mutation/file_container/upload.rb

@@ -31,16 +31,23 @@ module Ecoportal
             # @param other_tags [Array<String>, nil] tags — the only supported way to tag a
             #   container (there is no separate tag mutation; confirmed 2026-07-30).
             # @param container_id [String, nil] add a new VERSION to an existing container.
-            def query(filename:, filetype:, filesize:, url:, location_ids: nil, other_tags: nil, container_id: nil, **kargs, &block)
+            # @param client_mutation_id [String, nil] optional correlation/tracing id --
+            #   `UploadInput`'s own `clientMutationId` (confirmed in this file's own header,
+            #   `UploadInput { clientMutationId filename filetype filesize locationIds
+            #   otherTags url containerId }`). Omitted entirely when not given, so every
+            #   existing caller's input shape is byte-identical to before.
+            def query(filename:, filetype:, filesize:, url:, location_ids: nil, other_tags: nil,
+                      container_id: nil, client_mutation_id: nil, **kargs, &block)
               input = {
                 filename: filename,
                 filetype: filetype,
                 filesize: filesize.to_s,
                 url:      url
               }
-              input[:locationIds] = Array(location_ids) if location_ids
-              input[:otherTags]   = Array(other_tags)   if other_tags
-              input[:containerId] = container_id        if container_id
+              input[:locationIds]      = Array(location_ids) if location_ids
+              input[:otherTags]        = Array(other_tags)   if other_tags
+              input[:containerId]      = container_id        if container_id
+              input[:clientMutationId] = client_mutation_id  unless client_mutation_id.nil?
 
               super(input: input, **kargs, &block)
             end

data/lib/ecoportal/api/graphql/mutation/image/upload.rb

@@ -0,0 +1,88 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Mutation
+        module Image
+          # Registers an object already uploaded to S3 as a `TempImage` -- the upload-staging
+          # model behind Image Gallery (and other, non-gallery) image uploads.
+          #
+          # ★ Sibling to `Mutation::FileContainer::Upload`, NOT a variant of it: an Image
+          # Gallery image is explicitly NOT a `FileContainer`. Verified against the live
+          # ecoPortal server source (read-only, /tmp/work/ecoPortal):
+          #   * `app/graphql/mutations/images/upload.rb:1-23` -- the mutation builds an
+          #     `Enzyme::ImageReference::TempImage`, not `uploadFile`/`FileContainer`.
+          #   * `app/graphql/types/mutation_type.rb:224` -- schema field `uploadImage`
+          #     (`field :upload_image, mutation: Mutations::Images::Upload`).
+          #   * `app/graphql/types/enums/files/image_upload_type_enum.rb` -- `type:` is a
+          #     live enum (`image_gallery`, `policy_group`, `theme`, `user`, `organization`,
+          #     `brand`); `"image_gallery"` is the one `Base::Page::DataField::ImageGallery`
+          #     consumes.
+          #
+          # The SIGNATURE and S3-POST steps upstream of this call are IDENTICAL to the
+          # `uploadFile` flow (same `fileUploadSignature`, same multipart POST) -- see
+          # `FileUpload::Client#upload_image`, which shares its presign+store step with
+          # `#upload` and only diverges here, at registration.
+          #
+          # Verified against the live schema:
+          #   uploadImage(input: ImagesUploadInput!) -> ImagesUploadPayload
+          #     { clientMutationId errors item: TempImage }
+          #   ImagesUploadInput { clientMutationId key type id import }
+          class Upload < Logic::Mutation
+            field_name :uploadImage
+
+            class_resolver :payload_class, 'Ecoportal::API::GraphQL::Payload::ImagesUpload'
+
+            # @param key [String] the S3 object key produced by the S3 POST step.
+            # @param type [String, Symbol] live enum value -- `FileUpload::Client` always
+            #   passes `'image_gallery'` today; any other value is sent verbatim for a future
+            #   caller.
+            # @param id [String, nil] a target id the image is being uploaded FOR, in
+            #   contexts that need one (e.g. an existing brand/policy_group/user). Unused by
+            #   the Image Gallery context -- that attach happens later, via `updatePage`, not
+            #   here.
+            # @param import [Boolean] matches the live schema's own default (`true`).
+            # @param client_mutation_id [String, nil] optional correlation/tracing id --
+            #   `ImagesUploadInput`'s own `clientMutationId` (confirmed in this file's own
+            #   header, `ImagesUploadInput { clientMutationId key type id import }`). Omitted
+            #   entirely when not given, so every existing caller's input shape is
+            #   byte-identical to before.
+            def query(key:, type:, id: nil, import: true, client_mutation_id: nil, **kargs, &block)
+              super(input: build_input(key: key, type: type, id: id, import: import,
+                                       client_mutation_id: client_mutation_id), **kargs, &block)
+            end
+
+            private
+
+            def build_input(key:, type:, id:, import:, client_mutation_id: nil)
+              input = {key: key, type: type.to_s, import: import}
+              input[:id] = id if id
+              input[:clientMutationId] = client_mutation_id unless client_mutation_id.nil?
+              input
+            end
+
+            def basic_block(&block)
+              payload_block = block || default_payload_block
+              proc {
+                mutation(input: :ImagesUploadInput!) {
+                  uploadImage(input: :input, &payload_block)
+                }
+              }
+            end
+
+            def default_payload_block
+              proc {
+                errors { details fullMessages }
+                item {
+                  id
+                  s3Key
+                  complete
+                  error
+                }
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/mutation/image.rb

@@ -0,0 +1,14 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Mutation
+        # Namespaced `Image` (matches the schema's own `TempImageType`/`ImagesUploadInput`
+        # naming) -- sibling to `Mutation::FileContainer`, NOT a variant of it.
+        module Image
+        end
+      end
+    end
+  end
+end
+
+require_relative 'image/upload'

data/lib/ecoportal/api/graphql/mutation/template/create.rb

@@ -3,15 +3,47 @@ module Ecoportal
     class GraphQL
       module Mutation
         module Template
+          # `createPageTemplate(input: CreatePageTemplateInput!)` — creates a template page from
+          # a `WorkflowCommand` batch.
+          #
+          # ★ `registerId` IS NOT COSMETIC — it is what makes the create AUTHORIZABLE.
+          #
+          # The backend resolves a page's registers BY TAG
+          # (`NewEp::Pages::AssociatedRegisters`: org registers whose `filter_tags` are a subset
+          # of the page's `combined_tags`), and `RegisterTemplatePermissionChecker` returns
+          # `false` outright when that set is EMPTY. A template created without `registerId`
+          # carries no `base_tags`, so it is associated with ZERO registers, so the check fails
+          # regardless of what the account is granted — surfacing as the misleading
+          # `You are not authorized to perform: edit_template_basic_settings`.
+          # `Pages::Templates::CreateForm#bind_register!` is what closes that hole: given
+          # `register_id` it sets `page.base_tags = register.filter_tags` BEFORE the commands run.
+          #
+          # SHAPE (verified against the LIVE eu.live SDL, 2026-09-04): `registerId: ID` is an
+          # INPUT FIELD of `CreatePageTemplateInput`, not a sibling argument of the mutation —
+          # the backend mutation declares `argument :register_id, ID, required: false` next to
+          # `argument :commands`, but `Mutations::BaseMutation < GraphQL::Schema::RelayClassicMutation`
+          # folds every argument into the generated input object. So it travels inside `input:`,
+          # exactly like `commands`.
           class Create < Logic::Mutation
-            SCHEMA_VERSION = '20260605'.freeze
+            SCHEMA_VERSION = '20260904'.freeze
 
             field_name :createPageTemplate
 
             class_resolver :payload_class, 'Ecoportal::API::GraphQL::Payload::Template::Create'
 
-            def query(commands:, **kargs, &block)
-              super(input: { commands: commands }, **kargs, &block)
+            # @param commands [Array<Hash>] the `WorkflowCommand` batch.
+            # @param register_id [String, nil] the register to bind the new template to. Omitted
+            #   when nil — never sent as an explicit null, so existing call sites keep producing
+            #   the byte-identical input they produced before this key existed.
+            def query(commands:, register_id: nil, **kargs, &block)
+              super(input: self.class.build_input(commands: commands, register_id: register_id), **kargs, &block)
+            end
+
+            # Extracted so the omit-nil rule is testable without a client or a network stub.
+            def self.build_input(commands:, register_id: nil)
+              {commands: commands}.tap do |input|
+                input[:registerId] = register_id unless register_id.nil?
+              end
             end
 
             private

data/lib/ecoportal/api/graphql/mutation/template/update.rb

@@ -10,9 +10,11 @@ module Ecoportal
 
             class_resolver :payload_class, 'Ecoportal::API::GraphQL::Payload::Template::Update'
 
-            def query(id:, patch_ver:, commands:, **kargs, &block)
+            def query(id:, patch_ver:, commands:, client_mutation_id: nil, **kargs, &block)
+              input = { id: id, patchVer: patch_ver, commands: commands }
+              input[:clientMutationId] = client_mutation_id unless client_mutation_id.nil?
               super(
-                input: { id: id, patchVer: patch_ver, commands: commands },
+                input: input,
                 **kargs,
                 &block
               )

data/lib/ecoportal/api/graphql/mutation.rb

@@ -18,3 +18,4 @@ require_relative 'mutation/ai_summary'
 require_relative 'mutation/kickstand'
 require_relative 'mutation/template'
 require_relative 'mutation/file_container'
+require_relative 'mutation/image'

data/lib/ecoportal/api/graphql/payload/images_upload.rb

@@ -0,0 +1,14 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Payload
+        # `uploadImage` -> `ImagesUploadPayload { clientMutationId errors item: TempImage }`.
+        # Sibling to `Payload::Upload` (`uploadFile` -> `FileContainer`) -- NOT a variant of
+        # it. See `Base::TempImage`'s header for why the item type differs.
+        class ImagesUpload < Logic::Payload
+          class_resolver :item_class, 'Ecoportal::API::GraphQL::Model::TempImage'
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/payload.rb

@@ -22,3 +22,4 @@ require_relative 'payload/execute_workflow_commands'
 require_relative 'payload/kickstand'
 require_relative 'payload/template'
 require_relative 'payload/upload'
+require_relative 'payload/images_upload'

data/lib/ecoportal/api/graphql/query/pages.rb

@@ -4,7 +4,7 @@ module Ecoportal
       module Query
         # DB-backed full-data org search — returns PageUnion nodes with patchVer and field IDs.
         # Required pre-update fetch: always use this (not RegisterPreviewPages) before updatePage.
-        # See .ai-assistance/code/search_filters.md — "The Required Pattern: Find Before Mutate".
+        # See the repo's internal docs — "The Required Pattern: Find Before Mutate".
         class Pages < Logic::QueryConnection
           field_name :pages
           # Response nests under currentOrganization.pages; needed when instantiated

data/lib/ecoportal/api/graphql/query/permissions.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Query
         # Fetches the org-level permission set: currentOrganization.permissions.
-        # Returns a Model::Permissions whose ~83 canXXX fields are AuthorizationResult.
+        # Returns a Model::Permissions whose ~81 canXXX fields are AuthorizationResult.
         # Selects the :Permissions fragment (which spreads :AuthorizationResult per field).
         class Permissions < Logic::Query
           field_name :permissions

data/lib/ecoportal/api/graphql_version.rb

@@ -1,5 +1,5 @@
 module Ecoportal
   module API
-    GRAPQL_VERSION = '2.2.0'.freeze
+    GRAPQL_VERSION = '3.0.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ecoportal-api-graphql
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Oscar Segura
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-canonicalization
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -199,7 +213,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
-- README.md
+- README.gem.md
 - lib/ecoportal/api-graphql.rb
 - lib/ecoportal/api/common.graphql.rb
 - lib/ecoportal/api/common/graphql.rb
@@ -311,6 +325,7 @@ files:
 - lib/ecoportal/api/graphql/base/preview_page.rb
 - lib/ecoportal/api/graphql/base/register.rb
 - lib/ecoportal/api/graphql/base/resource.rb
+- lib/ecoportal/api/graphql/base/temp_image.rb
 - lib/ecoportal/api/graphql/base/template.rb
 - lib/ecoportal/api/graphql/base/template/change_log_entry.rb
 - lib/ecoportal/api/graphql/builder.rb
@@ -534,6 +549,7 @@ files:
 - lib/ecoportal/api/graphql/input/workflow_command/field_config/table.rb
 - lib/ecoportal/api/graphql/input/workflow_command/manage_copy_page_configuration.rb
 - lib/ecoportal/api/graphql/input/workflow_command/move_field.rb
+- lib/ecoportal/api/graphql/input/workflow_command/move_section_to_stage.rb
 - lib/ecoportal/api/graphql/input/workflow_command/move_stage.rb
 - lib/ecoportal/api/graphql/input/workflow_command/move_viewable_field.rb
 - lib/ecoportal/api/graphql/input/workflow_command/remove_action_tag.rb
@@ -624,8 +640,23 @@ files:
 - lib/ecoportal/api/graphql/model/preview_page.rb
 - lib/ecoportal/api/graphql/model/register.rb
 - lib/ecoportal/api/graphql/model/resource.rb
+- lib/ecoportal/api/graphql/model/temp_image.rb
 - lib/ecoportal/api/graphql/model/template.rb
+- lib/ecoportal/api/graphql/model/template/binding.rb
 - lib/ecoportal/api/graphql/model/template/change_log_entry.rb
+- lib/ecoportal/api/graphql/model/template/command_grouper.rb
+- lib/ecoportal/api/graphql/model/template/command_normalizer.rb
+- lib/ecoportal/api/graphql/model/template/command_synthesis.rb
+- lib/ecoportal/api/graphql/model/template/field.rb
+- lib/ecoportal/api/graphql/model/template/force.rb
+- lib/ecoportal/api/graphql/model/template/helper.rb
+- lib/ecoportal/api/graphql/model/template/instance.rb
+- lib/ecoportal/api/graphql/model/template/node.rb
+- lib/ecoportal/api/graphql/model/template/option.rb
+- lib/ecoportal/api/graphql/model/template/read.rb
+- lib/ecoportal/api/graphql/model/template/section.rb
+- lib/ecoportal/api/graphql/model/template/stage.rb
+- lib/ecoportal/api/graphql/model/template/staged_executor.rb
 - lib/ecoportal/api/graphql/model/user.rb
 - lib/ecoportal/api/graphql/mutation.rb
 - lib/ecoportal/api/graphql/mutation/action.rb
@@ -642,6 +673,8 @@ files:
 - lib/ecoportal/api/graphql/mutation/contractor_entity/update_manager_settings.rb
 - lib/ecoportal/api/graphql/mutation/file_container.rb
 - lib/ecoportal/api/graphql/mutation/file_container/upload.rb
+- lib/ecoportal/api/graphql/mutation/image.rb
+- lib/ecoportal/api/graphql/mutation/image/upload.rb
 - lib/ecoportal/api/graphql/mutation/kickstand.rb
 - lib/ecoportal/api/graphql/mutation/kickstand/bulk_update_jobs.rb
 - lib/ecoportal/api/graphql/mutation/kickstand/bulk_update_workflows.rb
@@ -706,6 +739,7 @@ files:
 - lib/ecoportal/api/graphql/payload/contractor_entity/update.rb
 - lib/ecoportal/api/graphql/payload/execute_workflow_commands.rb
 - lib/ecoportal/api/graphql/payload/force_commands.rb
+- lib/ecoportal/api/graphql/payload/images_upload.rb
 - lib/ecoportal/api/graphql/payload/kickstand.rb
 - lib/ecoportal/api/graphql/payload/kickstand/bulk_update_jobs.rb
 - lib/ecoportal/api/graphql/payload/kickstand/bulk_update_workflows.rb