dropbox-sign 1.5.0 → 1.6.1

data/templates/base_object.mustache

@@ -1,6 +1,31 @@
     # Builds the object from hash
     # @param [Hash] attributes Model attributes in the form of hash
     # @return [Object] Returns the model itself
+{{^useCustomTemplateCode}}
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      {{#parent}}
+      super(attributes)
+      {{/parent}}
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
     def self.build_from_hash(attributes)
 {{#discriminator}}
       if !attributes[self.openapi_discriminator_name].nil?
@@ -38,12 +63,18 @@
 
       self
     end
+{{/useCustomTemplateCode}}
 
     # Deserializes the data based on type
     # @param string type Data type
     # @param string value Value to be deserialized
     # @return [Object] Deserialized data
+{{^useCustomTemplateCode}}
+    def self._deserialize(type, value)
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
     def _deserialize(type, value)
+{{/useCustomTemplateCode}}
       case type.to_sym
       when :Time
         Time.parse(value)
@@ -76,7 +107,9 @@
           end
         end
       else # model
-        # models (e.g. Pet)
+{{^useCustomTemplateCode}}
+        # models (e.g. Pet) or oneOf
+{{/useCustomTemplateCode}}
         klass = {{moduleName}}.const_get(type)
         klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
       end
@@ -96,17 +129,37 @@
 
     # Returns the object in the form of hash
     # @return [Hash] Returns the object in the form of hash
+{{^useCustomTemplateCode}}
+    def to_hash
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
     def to_hash(include_nil = true)
+{{/useCustomTemplateCode}}
       hash = {{^parent}}{}{{/parent}}{{#parent}}super{{/parent}}
+{{^useCustomTemplateCode}}
+      self.class.attribute_map.each_pair do |attr, param|
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
       self.class.merged_attributes.each_pair do |attr, param|
+{{/useCustomTemplateCode}}
         value = self.send(attr)
         if value.nil?
+{{^useCustomTemplateCode}}
+          is_nullable = self.class.openapi_nullable.include?(attr)
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
           next unless include_nil
           is_nullable = self.class.merged_nullable.include?(attr)
+{{/useCustomTemplateCode}}
           next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
         end
 
+{{^useCustomTemplateCode}}
+        hash[param] = _to_hash(value)
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
         hash[param] = _to_hash(value, include_nil)
+{{/useCustomTemplateCode}}
       end
       hash
     end
@@ -115,15 +168,35 @@
     # For object, use to_hash. Otherwise, just return the value
     # @param [Object] value Any valid value
     # @return [Hash] Returns the value in the form of hash
+{{^useCustomTemplateCode}}
+    def _to_hash(value)
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
     def _to_hash(value, include_nil = true)
+{{/useCustomTemplateCode}}
       if value.is_a?(Array)
+{{^useCustomTemplateCode}}
+        value.compact.map { |v| _to_hash(v) }
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
         value.compact.map { |v| _to_hash(v, include_nil) }
+{{/useCustomTemplateCode}}
       elsif value.is_a?(Hash)
         {}.tap do |hash|
+{{^useCustomTemplateCode}}
+          value.each { |k, v| hash[k] = _to_hash(v) }
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
           value.each { |k, v| hash[k] = _to_hash(v, include_nil) }
+{{/useCustomTemplateCode}}
         end
       elsif value.respond_to? :to_hash
+{{^useCustomTemplateCode}}
+        value.to_hash
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
         value.to_hash(include_nil)
+{{/useCustomTemplateCode}}
       else
         value
       end

data/templates/configuration.mustache

@@ -2,9 +2,11 @@
 {{> api_info}}
 =end
 
+{{#useCustomTemplateCode}}
 module Dropbox
 end
 
+{{/useCustomTemplateCode}}
 module {{moduleName}}
   class Configuration
     # Defines url scheme
@@ -225,6 +227,55 @@ module {{moduleName}}
     end
 
     # Returns Auth Settings hash for api client.
+{{^useCustomTemplateCode}}
+    def auth_settings
+      {
+{{#authMethods}}
+{{#isApiKey}}
+        '{{name}}' =>
+          {
+            type: 'api_key',
+            in: {{#isKeyInHeader}}'header'{{/isKeyInHeader}}{{#isKeyInQuery}}'query'{{/isKeyInQuery}},
+            key: '{{keyParamName}}',
+            value: api_key_with_prefix('{{name}}'{{#vendorExtensions.x-auth-id-alias}}, '{{.}}'{{/vendorExtensions.x-auth-id-alias}})
+          },
+{{/isApiKey}}
+{{#isBasic}}
+{{#isBasicBasic}}
+        '{{name}}' =>
+          {
+            type: 'basic',
+            in: 'header',
+            key: 'Authorization',
+            value: basic_auth_token
+          },
+{{/isBasicBasic}}
+{{#isBasicBearer}}
+        '{{name}}' =>
+          {
+            type: 'bearer',
+            in: 'header',
+            {{#bearerFormat}}
+            format: '{{{.}}}',
+            {{/bearerFormat}}
+            key: 'Authorization',
+            value: "Bearer #{access_token_with_refresh}"
+          },
+{{/isBasicBearer}}
+{{/isBasic}}
+{{#isOAuth}}
+        '{{name}}' =>
+          {
+            type: 'oauth2',
+            in: 'header',
+            key: 'Authorization',
+            value: "Bearer #{access_token_with_refresh}"
+          },
+{{/isOAuth}}
+{{/authMethods}}
+      }
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
     def auth_settings()
       result = {}
 {{#authMethods}}
@@ -255,6 +306,7 @@ module {{moduleName}}
 {{/isBasic}}
 {{/authMethods}}
       return result
+{{/useCustomTemplateCode}}
     end
 
     # Returns an array of Server setting
@@ -262,7 +314,12 @@ module {{moduleName}}
       [
       {{#servers}}
         {
+{{^useCustomTemplateCode}}
+          url: "{{{url}}}",
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
           url: "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, ''),
+{{/useCustomTemplateCode}}
           description: "{{{description}}}{{^description}}No description provided{{/description}}",
           {{#variables}}
           {{#-first}}

data/templates/dropbox-LICENSE.mustache

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) {{licenseCopyrightYear}} dropbox.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/templates/gem.mustache

@@ -45,11 +45,13 @@ require '{{importPath}}'
 {{/apis}}
 {{/apiInfo}}
 
+{{#useCustomTemplateCode}}
 require '{{gemName}}/event_callback_helper'
 
 module Dropbox
 end
 
+{{/useCustomTemplateCode}}
 module {{moduleName}}
   class << self
     # Customize default settings for the SDK using block.

data/templates/gitignore.mustache

@@ -38,4 +38,7 @@ build/
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
 
-vendor
+{{#useCustomTemplateCode}}
+.openapi-generator
+vendor
+{{/useCustomTemplateCode}}

data/templates/gitlab-ci.mustache

@@ -0,0 +1,26 @@
+.ruby: &ruby
+  variables:
+    LANG: "C.UTF-8"
+  before_script:
+    - ruby -v
+    - bundle config set --local deployment true
+    - bundle install -j $(nproc)
+  parallel:
+    matrix:
+      - RUBY_VERSION: ['2.7', '3.0', '3.1']
+  image: "ruby:$RUBY_VERSION"
+  cache:
+    paths:
+      - vendor/ruby
+    key: 'ruby-$RUBY_VERSION'
+
+gem:
+  extends: .ruby
+  script:
+    - bundle exec rspec
+    - bundle exec rake build
+    - bundle exec rake install
+  artifacts:
+    paths:
+      - pkg/*.gem
+

data/templates/model.mustache

@@ -5,9 +5,11 @@
 require 'date'
 require 'time'
 
+{{#useCustomTemplateCode}}
 module Dropbox
 end
 
+{{/useCustomTemplateCode}}
 module {{moduleName}}
 {{#models}}
 {{#model}}
@@ -20,8 +22,22 @@ module {{moduleName}}
 {{>partial_oneof_module}}
 {{/-first}}
 {{/oneOf}}
+{{^useCustomTemplateCode}}
+{{#anyOf}}
+{{#-first}}
+{{>partial_anyof_module}}
+{{/-first}}
+{{/anyOf}}
+{{/useCustomTemplateCode}}
 {{^oneOf}}
+{{^useCustomTemplateCode}}
+{{^anyOf}}
+{{>partial_model_generic}}
+{{/anyOf}}
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
 {{>partial_model_generic}}
+{{/useCustomTemplateCode}}
 {{/oneOf}}
 {{/isEnum}}
 {{/model}}

data/templates/model_test.mustache

@@ -13,13 +13,16 @@ require 'date'
 {{#model}}
 describe {{moduleName}}::{{classname}} do
 {{^oneOf}}
+{{^anyOf}}
   let(:instance) { {{moduleName}}::{{classname}}.new }
 
   describe 'test an instance of {{classname}}' do
     it 'should create an instance of {{classname}}' do
-      expect(instance).to be_instance_of({{moduleName}}::{{classname}})
+      # uncomment below to test the instance creation
+      #expect(instance).to be_instance_of({{moduleName}}::{{classname}})
     end
   end
+
 {{#vars}}
   describe 'test attribute "{{{name}}}"' do
     it 'should work' do
@@ -37,6 +40,7 @@ describe {{moduleName}}::{{classname}} do
   end
 
 {{/vars}}
+{{/anyOf}}
 {{/oneOf}}
 {{#oneOf}}
 {{#-first}}

data/templates/partial_anyof_module.mustache

@@ -0,0 +1,96 @@
+{{^useCustomTemplateCode}}
+  {{#description}}
+  # {{{.}}}
+  {{/description}}
+  module {{classname}}
+    class << self
+      {{#anyOf}}
+      {{#-first}}
+      # List of class defined in anyOf (OpenAPI v3)
+      def openapi_any_of
+        [
+      {{/-first}}
+          :'{{{.}}}'{{^-last}},{{/-last}}
+      {{#-last}}
+        ]
+      end
+
+      {{/-last}}
+      {{/anyOf}}
+      # Builds the object
+      # @param [Mixed] Data to be matched against the list of anyOf items
+      # @return [Object] Returns the model or the data itself
+      def build(data)
+        # Go through the list of anyOf items and attempt to identify the appropriate one.
+        # Note:
+        # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
+        #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
+        # - TODO: scalar values are de facto behaving as if they were nullable.
+        # - TODO: logging when debugging is set.
+        openapi_any_of.each do |klass|
+          begin
+            next if klass == :AnyType # "nullable: true"
+            typed_data = find_and_cast_into_type(klass, data)
+            return typed_data if typed_data
+          rescue # rescue all errors so we keep iterating even if the current item lookup raises
+          end
+        end
+
+        openapi_any_of.include?(:AnyType) ? data : nil
+      end
+
+      private
+
+      SchemaMismatchError = Class.new(StandardError)
+
+      # Note: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
+      def find_and_cast_into_type(klass, data)
+        return if data.nil?
+
+        case klass.to_s
+        when 'Boolean'
+          return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
+        when 'Float'
+          return data if data.instance_of?(Float)
+        when 'Integer'
+          return data if data.instance_of?(Integer)
+        when 'Time'
+          return Time.parse(data)
+        when 'Date'
+          return Date.parse(data)
+        when 'String'
+          return data if data.instance_of?(String)
+        when 'Object' # "type: object"
+          return data if data.instance_of?(Hash)
+        when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
+          if data.instance_of?(Array)
+            sub_type = Regexp.last_match[:sub_type]
+            return data.map { |item| find_and_cast_into_type(sub_type, item) }
+          end
+        when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
+          if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
+            sub_type = Regexp.last_match[:sub_type]
+            return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
+          end
+        else # model
+          const = {{moduleName}}.const_get(klass)
+          if const
+            if const.respond_to?(:openapi_any_of) # nested anyOf model
+              model = const.build(data)
+              return model if model
+            else
+              # raise if data contains keys that are not known to the model
+              raise if const.respond_to?(:acceptable_attributes) && !(data.keys - const.acceptable_attributes).empty?
+              model = const.build_from_hash(data)
+              return model if model
+            end
+          end
+        end
+
+        raise # if no match by now, raise
+      rescue
+        raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
+      end
+    end
+  end
+{{/useCustomTemplateCode}}

data/templates/partial_model_enum_class.mustache

@@ -20,4 +20,4 @@
       return value if {{classname}}.all_vars.include?(value)
       raise "Invalid ENUM value #{value} for class #{{{classname}}}"
     end
-  end
+  end

data/templates/partial_model_generic.mustache

@@ -6,7 +6,9 @@
     {{#description}}
     # {{{.}}}
     {{/description}}
+{{#useCustomTemplateCode}}
     # @return [{{#vendorExtensions.x-int-or-string}}Integer, String{{/vendorExtensions.x-int-or-string}}{{^vendorExtensions.x-int-or-string}}{{{dataType}}}{{/vendorExtensions.x-int-or-string}}{{#isNullable}}, nil{{/isNullable}}]
+{{/useCustomTemplateCode}}
     attr_accessor :{{{name}}}
 
   {{/vars}}
@@ -53,16 +55,6 @@
       {{/parent}}
     end
 
-    # Returns attribute map of this model + parent
-    def self.merged_attributes
-      {{#parent}}
-      self.superclass.attribute_map.merge(self.attribute_map)
-      {{/parent}}
-      {{^parent}}
-      self.attribute_map
-      {{/parent}}
-    end
-
     # Attribute type mapping.
     def self.openapi_types
       {
@@ -72,16 +64,6 @@
       }
     end
 
-    # Attribute type mapping of this model + parent
-    def self.merged_types
-      {{#parent}}
-      self.superclass.openapi_types.merge(self.openapi_types)
-      {{/parent}}
-      {{^parent}}
-      self.openapi_types
-      {{/parent}}
-    end
-
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
@@ -93,6 +75,27 @@
       ])
     end
 
+{{#useCustomTemplateCode}}
+    # Returns attribute map of this model + parent
+    def self.merged_attributes
+      {{#parent}}
+      self.superclass.attribute_map.merge(self.attribute_map)
+      {{/parent}}
+      {{^parent}}
+      self.attribute_map
+      {{/parent}}
+    end
+
+    # Attribute type mapping of this model + parent
+    def self.merged_types
+      {{#parent}}
+      self.superclass.openapi_types.merge(self.openapi_types)
+      {{/parent}}
+      {{^parent}}
+      self.openapi_types
+      {{/parent}}
+    end
+
     # Returns list of attributes with nullable: true of this model + parent
     def self.merged_nullable
       {{#parent}}
@@ -103,6 +106,7 @@
       {{/parent}}
     end
 
+{{/useCustomTemplateCode}}
     {{#anyOf}}
     {{#-first}}
     # List of class defined in anyOf (OpenAPI v3)
@@ -116,6 +120,21 @@
 
     {{/-last}}
     {{/anyOf}}
+{{^useCustomTemplateCode}}
+    {{#allOf}}
+    {{#-first}}
+    # List of class defined in allOf (OpenAPI v3)
+    def self.openapi_all_of
+      [
+    {{/-first}}
+      :'{{{.}}}'{{^-last}},{{/-last}}
+    {{#-last}}
+      ]
+    end
+
+    {{/-last}}
+    {{/allOf}}
+{{/useCustomTemplateCode}}
     {{#discriminator}}
     {{#propertyName}}
     # discriminator's property name in OpenAPI v3
@@ -123,6 +142,7 @@
       :'{{{.}}}'
     end
 
+{{#useCustomTemplateCode}}
 {{#discriminator}}
     def self.discriminator_class_name(value)
       return nil unless value.is_a?(String)
@@ -137,8 +157,10 @@
     end
 {{/discriminator}}
 
+{{/useCustomTemplateCode}}
     {{/propertyName}}
     {{/discriminator}}
+{{#useCustomTemplateCode}}
 {{^discriminator}}
     # Attempt to instantiate and hydrate a new instance of this class
     # @param [Object] data Data to be converted
@@ -151,6 +173,7 @@
     end
 
 {{/discriminator}}
+{{/useCustomTemplateCode}}
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
     def initialize(attributes = {})
@@ -160,7 +183,12 @@
 
       # check to see if the attribute exists and convert string to symbol for hash key
       attributes = attributes.each_with_object({}) { |(k, v), h|
+{{^useCustomTemplateCode}}
+        if (!self.class.attribute_map.key?(k.to_sym))
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
         if (!self.class.merged_attributes.key?(k.to_sym))
+{{/useCustomTemplateCode}}
           fail ArgumentError, "`#{k}` is not a valid attribute in `{{{moduleName}}}::{{{classname}}}`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
         end
         h[k.to_sym] = v
@@ -190,6 +218,14 @@
       else
         self.{{{name}}} = {{{defaultValue}}}
       {{/defaultValue}}
+{{^useCustomTemplateCode}}
+      {{^defaultValue}}
+      {{#required}}
+      else
+        self.{{{name}}} = nil
+      {{/required}}
+      {{/defaultValue}}
+{{/useCustomTemplateCode}}
       end
       {{/vars}}
     end
@@ -197,6 +233,9 @@
     # Show invalid properties with the reasons. Usually used together with valid?
     # @return Array for valid properties with the reasons
     def list_invalid_properties
+{{^useCustomTemplateCode}}
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+{{/useCustomTemplateCode}}
       invalid_properties = {{^parent}}Array.new{{/parent}}{{#parent}}super{{/parent}}
       {{#vars}}
       {{^isNullable}}
@@ -259,6 +298,9 @@
     # Check to see if the all the properties in the model are valid
     # @return true if the model is valid
     def valid?
+{{^useCustomTemplateCode}}
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+{{/useCustomTemplateCode}}
       {{#vars}}
       {{^isNullable}}
       {{#required}}
@@ -335,12 +377,19 @@
     # @param [Object] {{{name}}} Value to be assigned
     def {{{name}}}=({{{name}}})
       {{^isNullable}}
-      {{#required}}
+{{^useCustomTemplateCode}}
       if {{{name}}}.nil?
         fail ArgumentError, '{{{name}}} cannot be nil'
       end
 
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
+      {{#required}}
+      if {{{name}}}.nil?
+        fail ArgumentError, '{{{name}}} cannot be nil'
+      end
       {{/required}}
+{{/useCustomTemplateCode}}
       {{/isNullable}}
       {{#maxLength}}
       if {{#isNullable}}!{{{name}}}.nil? && {{/isNullable}}{{{name}}}.to_s.length > {{{maxLength}}}

data/templates/partial_model_generic_doc.mustache

@@ -1,10 +1,38 @@
 # {{moduleName}}::{{classname}}
 
+{{#useCustomTemplateCode}}
 {{unescapedDescription}}
 
+{{/useCustomTemplateCode}}
 ## Properties
 
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
+{{^useCustomTemplateCode}}
+{{#vars}}
+| **{{name}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}[**{{dataType}}**]({{complexType}}.md){{/isPrimitiveType}} | {{description}} | {{^required}}[optional]{{/required}}{{#isReadOnly}}[readonly]{{/isReadOnly}}{{#defaultValue}}[default to {{.}}]{{/defaultValue}} |
+{{/vars}}
+
+## Example
+
+```ruby
+require '{{{gemName}}}'
+
+{{^vars}}
+instance = {{moduleName}}::{{classname}}.new()
+{{/vars}}
+{{#vars}}
+{{#-first}}
+instance = {{moduleName}}::{{classname}}.new(
+{{/-first}}
+  {{name}}: {{example}}{{^-last}},{{/-last}}
+{{#-last}}
+)
+{{/-last}}
+{{/vars}}
+```
+{{/useCustomTemplateCode}}
+{{#useCustomTemplateCode}}
 {{#vars}}| `{{name}}`{{#required}}<sup>*_required_</sup>{{/required}} | {{#isPrimitiveType}}```{{{dataType}}}```{{/isPrimitiveType}}{{^isPrimitiveType}}[```{{{dataType}}}```]({{complexType}}.md){{/isPrimitiveType}} | REPLACE_ME_WITH_DESCRIPTION_BEGIN {{unescapedDescription}} REPLACE_ME_WITH_DESCRIPTION_END | {{#isReadOnly}} [readonly]{{/isReadOnly}}{{#defaultValue}} [default to {{{.}}}]{{/defaultValue}} |
 {{/vars}}
+{{/useCustomTemplateCode}}