aws-sdk-code-generator 0.1.0.pre → 0.2.0.pre

data/lib/aws-sdk-code-generator/syntax_example_hash.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module AwsSdkCodeGenerator
+  class SyntaxExampleHash
+
+    include Helper
+
+    # @option options [required, Hash] :api
+    # @option options [required, Hash] :shape_ref
+    def initialize(options = {})
+      @api = options.fetch(:api)
+      @shape = options.fetch(:shape)
+      @async = options[:async] || false
+    end
+
+    def format(indent = '')
+      struct(@shape, indent, [])
+    end
+
+    private
+
+    def ref_value(ref, i, visited)
+      if visited.include?(ref['shape'])
+        return "{\n#{i}  # recursive #{ref['shape']}\n#{i}}"
+      else
+        visited  = visited + [ref['shape']]
+      end
+
+      s = shape(ref)
+      case s['type']
+      when 'structure'
+        if ref['shape'] == 'AttributeValue'
+          '"value"'
+        else
+          struct(s, i, visited)
+        end
+
+      when 'blob'
+        if ref['streaming']
+          'source_file'
+        else
+          '"data"'
+        end
+
+      when 'list' then list(s, i, visited)
+      when 'map' then map(s, i, visited)
+      when 'boolean' then "false"
+      when 'integer', 'long' then '1'
+      when 'float', 'double' then '1.0'
+      when 'byte' then '97'
+      when 'character' then '"a"'
+      when 'string' then string(ref)
+      when 'timestamp' then 'Time.now'
+      else raise "unsupported shape #{s['type'].inspect}"
+      end
+    end
+
+    def struct(struct_shape, i, visited)
+      lines = ['{']
+      unless struct_shape['members'].nil?
+        struct_shape['members'].each_pair do |member_name, member_ref|
+          next if member_ref['documented'] === false
+          # input eventstream shouldn't be provided from params
+          if @api['shapes'][member_ref['shape']]['eventstream'] === true
+            lines << "#{i}  input_event_stream_hander: EventStreams::#{member_ref['shape']}.new,"
+          else
+            lines << struct_member(struct_shape, member_name, member_ref, i, visited)
+          end
+        end
+      end
+      lines << "#{i}}"
+      lines.join("\n")
+    end
+
+    def struct_member(struct, member_name, member_ref, i, visited)
+      entry = "#{i}  #{underscore(member_name)}: #{ref_value(member_ref, i + '  ', visited)},"
+      required = (struct['required'] || []).include?(member_name)
+      apply_comments(member_ref, entry, required: required)
+    end
+
+    def list(list_shape, i, visited)
+      member_ref = list_shape['member']
+      if complex?(member_ref)
+        complex_list(member_ref, i, visited)
+      else
+        scalar_list(member_ref, i, visited)
+      end
+    end
+
+    def scalar_list(member_ref, i, visited)
+      "[#{ref_value(member_ref, i, visited)}]"
+    end
+
+    def complex_list(member_ref, i, visited)
+      "[\n#{i}  #{ref_value(member_ref, i + '  ', visited)},\n#{i}]"
+    end
+
+    def map(map_shape, i, visited)
+      key = string(map_shape['key'])
+      value = ref_value(map_shape['value'], i + '  ', visited)
+      "{\n#{i}  #{key} => #{value},#{comments(map_shape['value'], false)}\n#{i}}"
+    end
+
+    def string(ref)
+      string_shape = shape(ref)
+      if string_shape['enum']
+        string_shape['enum'].first.inspect
+      else ref['shape']
+        ref['shape'].inspect
+      end
+    end
+
+    def apply_comments(ref, text, options = {})
+      required = options.fetch(:required)
+      lines = text.lines.to_a
+      if lines[0].match(/\n$/)
+        lines[0] = lines[0].sub(/\n$/, comments(ref, required) + "\n")
+      else
+        lines[0] += comments(ref, required)
+      end
+      lines.join
+    end
+
+    def comments(ref, required)
+      comments = []
+      if ref[:response_target]
+        comments << 'where to write response data, file path, or IO object'
+      end
+      if ref[:streaming]
+        comments << 'file/IO object, or string data'
+      end
+      if required
+        comments << 'required'
+      end
+      if enum = enum_values(ref)
+        comments << "accepts #{enum.to_a.join(', ')}"
+      end
+      if ddb_av?(ref)
+        comments << 'value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>'
+      end
+      comments == [] ? '' : " # #{comments.join(', ')}"
+    end
+
+    def enum_values(ref)
+      s = shape(ref)
+      case s['type']
+      when 'list' then enum_values(s['member'])
+      when 'string' then s['enum']
+      else nil
+      end
+    end
+
+    def complex?(ref)
+      s = shape(ref)
+      if s['type'] == 'structure'
+        !ddb_av?(ref)
+      else
+        s['type'] == 'list' || s['type'] == 'map'
+      end
+    end
+
+    def ddb_av?(ref)
+      s = shape(ref)
+      case s['type']
+      when 'list' then ddb_av?(s['member'])
+      when 'structure' then ref['shape'] == 'AttributeValue'
+      else false
+      end
+    end
+
+  end
+end

data/lib/aws-sdk-code-generator/underscore.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AwsSdkCodeGenerator
   module Underscore
     class << self
@@ -10,11 +12,12 @@ module AwsSdkCodeGenerator
       # @param [String] string
       # @return [String] Returns the underscored version of the given string.
       def underscore(string)
-        string.
-          gsub(@irregular_regex) { |word| '_' + @irregular_inflections[word] }.
-          gsub(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2').
-          scan(/[a-z0-9]+|\d+|[A-Z0-9]+[a-z]*/).
-          join('_').downcase
+        new_string = string.dup
+        new_string.gsub!(@irregular_regex) { |word| "_#{@irregular_inflections[word]}" }
+        new_string.gsub!(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2'.freeze)
+        new_string = new_string.scan(/[a-z0-9]+|\d+|[A-Z0-9]+[a-z]*/).join('_'.freeze)
+        new_string.downcase!
+        new_string
       end
 
       # @param [String<JMESPath>]
@@ -38,6 +41,8 @@ module AwsSdkCodeGenerator
       'iSCSI' => 'iscsi',
       'ACLs' => 'acls',
       'Md5s' => 'md5s',
+      'HIT' => 'hit',
+      'URL' => 'url',
       #'SSEKMS' => 'sse_kms',
     })
 

data/lib/aws-sdk-code-generator/view.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mustache'
 
 module AwsSdkCodeGenerator
@@ -15,9 +17,40 @@ module AwsSdkCodeGenerator
       subclass.raise_on_context_miss = true
     end
 
+    # @param (see Underscore.underscore)
+    # @option (see Underscore.underscore)
+    # @return (see Underscore.underscore)
     def underscore(string)
       Underscore.underscore(string)
     end
 
+    # @param (see Underscore.underscore_jmespath)
+    # @option (see Underscore.underscore_jmespath)
+    # @return (see Underscore.underscore_jmespath)
+    def underscore_jmespath(string)
+      Underscore.underscore_jmespath(string)
+    end
+
+    # @param (see Docstring.html_to_markdown)
+    # @option (see Docstring.html_to_markdown)
+    # @return (see Docstring.html_to_markdown)
+    def html_to_markdown(html, options = {})
+      Docstring.html_to_markdown(html, options)
+    end
+
+    # @param (see Docstring.block_comment)
+    # @option (see Docstring.block_comment)
+    # @return (see Docstring.block_comment)
+    def block_comment(text, options = {})
+      Docstring.block_comment(text, options = {})
+    end
+
+    # @param (see Docstring.join_docstrings)
+    # @option (see Docstring.join_docstrings)
+    # @return (see Docstring.join_docstrings)
+    def join_docstrings(docs, options = {})
+      Docstring.join_docstrings(docs, options)
+    end
+
   end
 end

data/lib/aws-sdk-code-generator/views.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'gemspec'
 
 module Views; end

data/lib/aws-sdk-code-generator/views/apig_endpoint_class.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+
+    class APIGEndpointClass < View
+
+      # @option options [required, String] :module_name
+      # @option options [required, String] :default_endpoint
+      def initialize(options)
+        @module_name = options.fetch(:module_name)
+        endpoint = options.fetch(:default_endpoint)
+        unless endpoint.start_with?('http://') || endpoint.start_with?('https://')
+          endpoint = "https://#{endpoint}"
+        end
+        @default_endpoint = endpoint
+      end
+
+      attr_reader :module_name
+
+      attr_reader :default_endpoint
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/apig_readme.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class APIGReadme < View
+
+      # @option options [required, String] :service_name
+      # @option options [required, String] :module_name
+      # @option options [required, String] :gem_name
+      # @option options [required, String] :gem_major_version
+      def initialize(options)
+        @service_name = options.fetch(:service_name)
+        @module_name = options.fetch(:module_name)
+        @gem_name = options.fetch(:gem_name)
+        @gem_major_version = options.fetch(:gem_major_version)
+      end
+
+      # @return [String]
+      attr_reader :module_name
+
+      # @return [String]
+      attr_reader :gem_major_version
+
+      # @return [String]
+      attr_reader :gem_name
+
+      # @return [String]
+      attr_reader :service_name
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/async_client_class.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class AsyncClientClass < View
+
+      # @option options [required, String] :service_identifier
+      # @option options [required, String] :service_name
+      # @option options [required, String] :module_name
+      # @option options [required, String] :gem_name
+      # @option options [required, String] :gem_version
+      # @option options [required, String] :aws_sdk_core_lib_path
+      # @option options [required, String] :protocol
+      # @option options [required, String] :signature_version
+      # @option options [required, Hash] :add_plugins
+      # @option options [required, Array] :remove_plugins
+      # @option options [required, Hash] :api
+      # @option options [Hash] :client_examples
+      def initialize(options)
+        @service_identifier = options.fetch(:service_identifier)
+        @service_name = options.fetch(:service_name)
+        @module_name = options.fetch(:module_name)
+        @gem_name = options.fetch(:gem_name)
+        @gem_version = options.fetch(:gem_version)
+        @plugins = PluginList.new(options)
+        @client_constructor = ClientConstructor.new(plugins: @plugins)
+        @operations = ClientOperationList.new(options).to_a
+      end
+
+      # @return [String]
+      attr_reader :service_identifier
+
+      # @return [String]
+      attr_reader :service_name
+
+      # @return [String]
+      attr_reader :module_name
+
+      # @return [String]
+      attr_reader :gem_name
+
+      # @return [String]
+      attr_reader :gem_version
+
+      # @return [ClientConstructor]
+      attr_reader :client_constructor
+
+      # @return [Array<Operation>]
+      attr_reader :operations
+
+      # @return [String|nil]
+      def generated_src_warning
+        GENERATED_SRC_WARNING
+      end
+
+      # @return [Array<String>]
+      def plugin_requires
+        @plugins.map(&:require_path)
+      end
+
+      # @return [Array<String>]
+      def plugin_class_names
+        @plugins.map(&:class_name)
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/authorizer_class.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+
+    class AuthorizerClass < View
+
+      # @option options [required, String] :module_name
+      def initialize(options)
+        @module_name = options.fetch(:module_name)
+      end
+
+      attr_reader :module_name
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/client_api_module.rb

@@ -0,0 +1,583 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class ClientApiModule < View
+
+      include Helper
+
+      SKIP_TRAITS = Set.new(%w(shape deprecated location locationName documentation))
+
+      SHAPE_CLASSES = {
+        'blob' => 'BlobShape',
+        'byte' => 'IntegerShape',
+        'boolean' => 'BooleanShape',
+        'character' => 'StringShape',
+        'double' => 'FloatShape',
+        'float' => 'FloatShape',
+        'integer' => 'IntegerShape',
+        'list' => 'ListShape',
+        'long' => 'IntegerShape',
+        'map' => 'MapShape',
+        'string' => 'StringShape',
+        'structure' => 'StructureShape',
+        'timestamp' => 'TimestampShape'
+      }
+
+      SHAPE_KEYS = {
+        # keep
+        'flattened' => true,
+        'timestampFormat' => true, # glacier api customization
+        'xmlNamespace' => true,
+        'streaming' => true, # transfer-encoding
+        'requiresLength' => true, # transder-encoding
+        # event stream modeling
+        'event' => false,
+        'eventstream' => false,
+        'eventheader' => false,
+        'eventpayload' => false,
+        # ignore
+        'synthetic' => false,
+        'box' => false,
+        'fault' => false,
+        'error' => false,
+        'deprecated' => false,
+        'deprecatedMessage' => false,
+        'type' => false,
+        'documentation' => false,
+        'members' => false,
+        'member' => false,
+        'key' => false,
+        'locationName' => false,
+        'value' => false,
+        'required' => false,
+        'enum' => false,
+        'exception' => false,
+        'payload' => false,
+        'pattern' => false,
+        'sensitive' => false,
+        'min' => false,
+        'max' => false,
+        'wrapper' => false,
+        'xmlOrder' => false,
+        'retryable' => false
+      }
+
+      METADATA_KEYS = {
+        # keep all
+        'endpointPrefix' => true,
+        'signatureVersion' => true,
+        'signingName' => true,
+        'serviceFullName' => true,
+        'protocol' => true,
+        'targetPrefix' => true,
+        'jsonVersion' => true,
+        'errorPrefix' => true,
+        'timestampFormat' => true, # glacier api customization
+        'xmlNamespace' => true,
+        'protocolSettings' => {}, # current unused unless for h2 exclude
+        'serviceId' => true,
+        'apiVersion' => true,
+        'checksumFormat' => true,
+        'globalEndpoint' => true,
+        'serviceAbbreviation' => true,
+        'uid' => true
+      }
+
+      # @option options [required, Service] :service
+      def initialize(options)
+        @service = options.fetch(:service)
+      end
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
+      # @return [String]
+      def module_name
+        @service.module_name
+      end
+
+      # @return [String<YYYY-MM-DD>]
+      def api_version
+        @service.api_version
+      end
+
+      # @return [Array<Shape>]
+      def shapes
+        shape_enum.map do |shape_name, shape|
+          # APIG model, shape can start with downcase and with "__"
+          if @service.protocol == 'api-gateway'
+            shape_name = lstrip_prefix(upcase_first(shape_name))
+          end
+          Shape.new.tap do |s|
+            s.name = shape_name
+            s.class_name, shape = shape_class_name(shape)
+            s.constructor_args = shape_constructor_args(shape_name, shape)
+          end
+        end
+      end
+
+      def shape_definitions
+        shape_enum.inject([]) do |groups, (shape_name, shape)|
+          # APIG model, shape can start with downcase and with "__"
+          if @service.protocol == 'api-gateway'
+            shape_name = lstrip_prefix(upcase_first(shape_name))
+          end
+          lines = []
+          if non_error_struct?(shape)
+            required = Set.new(shape['required'] || [])
+            unless shape['members'].nil?
+              shape['members'].each do |member_name, member_ref|
+                lines << "#{shape_name}.add_member(:#{underscore(member_name)}, #{shape_ref(member_ref, member_name, required)})"
+              end
+            end
+            lines << "#{shape_name}.struct_class = Types::#{shape_name}"
+            if payload = shape['payload']
+              lines << "#{shape_name}[:payload] = :#{underscore(payload)}"
+              lines << "#{shape_name}[:payload_member] = #{shape_name}.member(:#{underscore(payload)})"
+            end
+            groups << lines.join("\n")
+          elsif error_struct?(shape)
+            required = Set.new(shape['required'] || [])
+            unless shape['members'].nil?
+              shape['members'].each do |member_name, member_ref|
+                lines << "#{shape_name}.add_member(:#{underscore(member_name)}, #{shape_ref(member_ref, member_name, required)})"
+              end
+            end
+            lines << "#{shape_name}.struct_class = Types::#{shape_name}"
+            groups << lines.join("\n")
+          elsif shape['type'] == 'list'
+            lines << "#{shape_name}.member = #{shape_ref(shape['member'])}"
+            groups << lines.join("\n")
+          elsif shape['type'] == 'map'
+            lines << "#{shape_name}.key = #{shape_ref(shape['key'])}"
+            lines << "#{shape_name}.value = #{shape_ref(shape['value'])}"
+            groups << lines.join("\n")
+          else
+            groups
+          end
+        end
+      end
+
+      # @return [Array<Hash>]
+      def metadata
+        metadata = []
+        @service.api.fetch('metadata', {}).keys.sort.each do |key|
+          if METADATA_KEYS[key]
+            metadata << {
+              key: key.inspect,
+              value: @service.api['metadata'][key].inspect
+            }
+          elsif METADATA_KEYS[key].nil?
+            raise "unhandled metadata key #{key.inspect}"
+          end
+        end
+        metadata
+      end
+
+      def operations
+        @service.api['operations'].map do |operation_name, operation|
+          Operation.new.tap do |o|
+            o.name = operation['name'] || operation_name
+            o.method_name = underscore(operation_name)
+            o.http_method = operation['http']['method']
+            o.http_request_uri = operation['http']['requestUri']
+            o.http_checksum_required = true if operation['httpChecksumRequired']
+            %w(input output).each do |key|
+              if operation[key]
+                o.shape_references << "o.#{key} = #{operation_ref(operation[key])}"
+              else
+                o.shape_references << "o.#{key} = Shapes::ShapeRef.new(shape: Shapes::StructureShape.new(struct_class: Aws::EmptyStructure))"
+              end
+            end
+            o.error_shape_names = operation.fetch('errors', []).map {|e| e['shape'] }
+            o.deprecated = true if operation['deprecated']
+            o.endpoint_operation = true if operation['endpointoperation']
+            if operation.key?('endpointdiscovery')
+              # "endpointdiscovery" trait per operation
+              # contains hash values of configuration,
+              # current acked field: "required"
+              o.endpoint_discovery_available = true
+              o.endpoint_discovery = operation['endpointdiscovery'].inject([]) do |a, (k, v)|
+                a << { key: k.inspect, value: v.inspect }
+                a
+              end
+            # endpoint trait cannot be co-exist with endpoint discovery
+            elsif operation.key?('endpoint')
+              # endpoint trait per operation, cannot be enabled with endpoint discovery
+              o.endpoint_trait = true
+              o.endpoint_pattern = operation['endpoint'].inject([]) do |a, (k, v)|
+                a << { key: k.inspect, value: v.inspect }
+                a
+              end
+            end
+            o.authorizer = operation['authorizer'] if operation.key?('authorizer')
+            o.authtype = operation['authtype'] if operation.key?('authtype')
+            o.require_apikey = operation['requiresApiKey'] if operation.key?('requiresApiKey')
+            o.pager = pager(operation_name)
+            o.async = @service.protocol_settings['h2'] == 'eventstream' &&
+              AwsSdkCodeGenerator::Helper.operation_eventstreaming?(operation, @service.api)
+          end
+        end
+      end
+
+      def apig_authorizer
+        return nil unless @service.api.key? 'authorizers'
+        @service.api['authorizers'].map do |name, authorizer|
+          Authorizer.new.tap do |a|
+            a.name = name
+            a.authorizer_name = underscore(name)
+            a.type = authorizer['type'] if authorizer.key? 'type'
+            if authorizer.key? 'placement'
+              a.location = authorizer['placement']['location']
+              a.location_name = authorizer['placement']['name']
+            end
+          end
+        end
+      end
+
+      def endpoint_operation
+        @service.api['operations'].each do |name, ref|
+          return underscore(name) if ref['endpointoperation']
+        end
+        nil
+      end
+
+      def require_endpoint_discovery
+        @service.require_endpoint_discovery
+      end
+
+      private
+
+      def shape_class_name(shape)
+        type = shape['type']
+        # APIG time serializing difference
+        if @service.protocol == 'api-gateway' && type == 'timestamp'
+          shape['timestampFormat'] = 'iso8601'
+        end
+        if SHAPE_CLASSES.key?(type)
+          ["Shapes::#{SHAPE_CLASSES[type]}", shape]
+        else
+          raise ArgumentError, "unsupported shape type `#{type}'"
+        end
+      end
+
+      def shape_constructor_args(shape_name, shape)
+        args = []
+        args << "name: '#{shape_name}'"
+        shape.each_pair do |key, value|
+          if SHAPE_KEYS[key]
+            args << "#{key}: #{value.inspect}"
+          elsif SHAPE_KEYS[key].nil?
+            raise "unhandled shape key #{key.inspect}"
+          end
+        end
+        args.join(', ')
+      end
+
+      def shape_enum
+        unless @service.protocol_settings.empty?
+          if @service.protocol_settings['h2'] == 'eventstream'
+            # some event shapes shared with error shapes
+            # might missing event trait
+            @service.api['shapes'].each do |_, shape|
+              if shape['eventstream']
+                # add event trait to all members if not exists
+                shape['members'].each do |name, ref|
+                  @service.api['shapes'][ref['shape']]['event'] = true
+                end
+              end
+            end
+          end
+        end
+        Enumerator.new do |y|
+          @service.api.fetch('shapes', {}).keys.sort.each do |shape_name|
+            y.yield(shape_name, @service.api['shapes'].fetch(shape_name))
+          end
+        end
+      end
+
+      def non_error_struct?(shape)
+        if !!shape['event']
+          shape['type'] == 'structure'
+        else
+          shape['type'] == 'structure' &&
+            !shape['error'] &&
+            !shape['exception']
+        end
+      end
+
+      def error_struct?(shape)
+        shape['type'] == 'structure' && !!!shape['event'] &&
+          (shape['error'] || shape['exception'])
+      end
+
+      def structure_shape_enum
+        Enumerator.new do |y|
+          shape_enum.each do |shape_name, shape|
+            # non error types && non empty error struct
+            if non_error_struct?(shape) || error_struct?(shape)
+              y.yield(shape_name, shape)
+            end
+          end
+        end
+      end
+
+      def shape_ref(ref, member_name = nil, required = Set.new)
+        ref_name = ref['shape']
+        if  @service.protocol == 'api-gateway'
+          ref_name = lstrip_prefix(ref_name)
+        end
+        line = "Shapes::ShapeRef.new(shape: #{ref_name}"
+        line += shape_ref_required(required, member_name)
+        line += shape_ref_deprecated(ref)
+        line += shape_ref_event(ref)
+        line += shape_ref_eventstream(ref)
+        line += shape_ref_eventpayload(ref)
+        line += shape_ref_eventheader(ref)
+        line += shape_ref_location(ref)
+        line += shape_ref_location_name(member_name, ref)
+        line += shape_ref_metadata(ref, member_name)
+        line += ")"
+        line
+      end
+
+      def shape_ref_required(required, member_name)
+        if required.include?(member_name)
+          ", required: true"
+        else
+          ""
+        end
+      end
+
+      def shape_ref_deprecated(ref)
+        if ref['deprecated'] || @service.api['shapes'][ref['shape']]['deprecated']
+          ", deprecated: true"
+        else
+          ""
+        end
+      end
+
+      def shape_ref_eventstream(ref)
+        if @service.api['shapes'][ref['shape']]['eventstream']
+          ", eventstream: true"
+        else
+          ''
+        end
+      end
+
+      def shape_ref_event(ref)
+        if @service.api['shapes'][ref['shape']]['event']
+          ", event: true"
+        else
+          ''
+        end
+      end
+
+      def shape_ref_eventpayload(ref)
+        if ref['eventpayload']
+          type = @service.api['shapes'][ref['shape']]['type']
+          ", eventpayload: true, eventpayload_type: '#{type}'"
+        else
+          ''
+        end
+      end
+
+      def shape_ref_eventheader(ref)
+        if ref['eventheader']
+          type = @service.api['shapes'][ref['shape']]['type']
+          ", eventheader: true, eventheader_type: '#{type}'"
+        else
+          ''
+        end
+      end
+
+      def shape_ref_location(ref)
+        if ref['location']
+          ", location: #{ref['location'].inspect}"
+        else
+          ''
+        end
+      end
+
+      def shape_ref_location_name(member_name, member_ref)
+        location_name = member_ref['locationName']
+        location_name ||= member_name unless member_ref['location'] == 'headers'
+        location_name ? ", location_name: #{location_name.inspect}" : ""
+      end
+
+      def shape_ref_metadata(member_ref, member_name)
+        metadata = member_ref.inject({}) do |hash, (key, value)|
+          hash[key] = value unless SKIP_TRAITS.include?(key)
+          if key == 'hostLabel'
+            hash['hostLabelName'] = member_name
+          end
+          hash
+        end
+        if metadata.empty?
+          ""
+        else
+          ", metadata: #{metadata.inspect}"
+        end
+      end
+
+      def pager(operation_name)
+        if @service.paginators && @service.paginators['pagination'][operation_name]
+          p = @service.paginators['pagination'][operation_name]
+          input = Array(p['input_token'])
+          output = Array(p['output_token'])
+          tokens = {}
+          input.each.with_index do |key, n|
+            tokens[underscore_jmespath(output[n])] = underscore_jmespath(key)
+          end
+          options = {}
+          options[:more_results] = underscore_jmespath(p['more_results']) if p['more_results']
+          options[:limit_key] = underscore_jmespath(p['limit_key']) if p['limit_key']
+          options[:tokens] = tokens
+          options = HashFormatter.new(
+            quote_strings: true,
+            inline: true,
+            wrap: false,
+          ).format(options)
+          "o[:pager] = Aws::Pager.new(#{options})" unless tokens.empty?
+        end
+      end
+
+      def operation_ref(ref)
+        metadata = ref.dup
+        shape_name = metadata.delete('shape')
+        # APIG model, shape can start with downcase and with "__"
+        if @service.protocol == 'api-gateway'
+          shape_name = lstrip_prefix(upcase_first(shape_name))
+        end
+        if metadata.empty?
+          options = ''
+        else
+          options = {}
+          metadata.each_pair do |key, value|
+            next if key == 'resultWrapper'
+            if key == 'locationName'
+              options[:location_name] = value.inspect
+            else
+              options[:metadata] ||= {}
+              options[:metadata][key] = value.inspect
+            end
+          end
+          if options.empty?
+            options = ''
+          else
+            opts = HashFormatter.new(wrap:false).format(options)
+            if opts[0] == "\n"
+              options = ",#{opts}"
+            else
+              options = ", #{opts}"
+            end
+          end
+        end
+        "Shapes::ShapeRef.new(shape: #{shape_name}#{options})"
+      end
+
+
+      class Shape
+
+        # @return [String]
+        attr_accessor :name
+
+        # @return [String<ClassName>]
+        attr_accessor :class_name
+
+        # @return [String]
+        attr_accessor :constructor_args
+
+      end
+
+      class Operation
+
+        def initialize
+          @shape_references = []
+          @error_shape_names = []
+        end
+
+        # @return [String] The UpperCamelCase operation name.
+        attr_accessor :name
+
+        # @return [String] The underscored method name.
+        attr_accessor :method_name
+
+        # @return [String] GET, PUT, POST, etc.
+        attr_accessor :http_method
+
+        # @return [String] "/", "/path?query", etc.
+        attr_accessor :http_request_uri
+
+        # @return [Boolean]
+        attr_accessor :http_checksum_required
+
+        # @return [Array<String>]
+        attr_accessor :shape_references
+
+        # @return [Array<String>]
+        attr_accessor :error_shape_names
+
+        # @return [Boolean]
+        attr_accessor :deprecated
+
+        # @return [Boolean]
+        attr_accessor :endpoint_discovery_available
+
+        # @return [Boolean]
+        attr_accessor :endpoint_operation
+
+        # @return [Array]
+        attr_accessor :endpoint_discovery
+
+        # @return [String,nil]
+        attr_accessor :authtype
+
+        # @return [Boolean]
+        attr_accessor :endpoint_trait
+
+        # @return [Array]
+        attr_accessor :endpoint_pattern
+
+        # APIG only
+        # @return [Boolean]
+        attr_accessor :require_apikey
+
+        # APIG only
+        # @return [String, nil]
+        attr_accessor :authorizer
+
+        # @return [Pager, nil]
+        attr_accessor :pager
+
+        # @return [Boolean]
+        attr_accessor :async
+
+      end
+
+      # APIG SDK only
+      class Authorizer
+
+        # @return [String]
+        attr_accessor :name
+
+        # @return [String]
+        attr_accessor :authorizer_name
+
+        # @return [String]
+        attr_accessor :type
+
+        # @return [String]
+        attr_accessor :location
+
+        # @return [String]
+        attr_accessor :location_name
+
+      end
+    end
+  end
+end