datadog_api_client 1.7.0 → 1.8.0

data/.generator/src/generator/openapi.py

@@ -0,0 +1,347 @@
+import pathlib
+import yaml
+import warnings
+from jsonref import JsonRef
+from urllib.parse import urlparse
+from yaml import CSafeLoader
+
+from . import formatter
+
+
+def load(filename):
+    path = pathlib.Path(filename)
+    with path.open() as fp:
+        return JsonRef.replace_refs(yaml.load(fp, Loader=CSafeLoader))
+
+
+def get_name(schema):
+    name = None
+    if hasattr(schema, "__reference__"):
+        name = schema.__reference__["$ref"].split("/")[-1]
+
+    return name
+
+
+def type_to_ruby(schema, alternative_name=None):
+    """Return Ruby type name for the type."""
+    name = get_name(schema)
+    if name:
+        if "enum" in schema:
+            return name
+        if (
+            not schema.get("additionalProperties")
+            and schema.get("type", "object") == "object"
+        ):
+            return name
+
+    type_ = schema.get("type")
+    if type_ is None:
+        if "items" in schema:
+            type_ = "array"
+        elif "properties" in schema:
+            type_ = "object"
+        else:
+            type_ = "object"
+            warnings.warn(
+                f"Unknown type for schema: {schema} ({name or alternative_name})"
+            )
+
+    if type_ == "integer":
+        return "Integer"
+    elif type_ == "number":
+        return "Float"
+    elif type_ == "string":
+        format_ = schema.get("format")
+        if format_ in {"date", "date-time"}:
+            return "Time"
+        elif format_ == "binary":
+            return "File"
+        return "String"
+    elif type_ == "boolean":
+        return "Boolean"
+    elif type_ == "array":
+        return "Array<{}>".format(type_to_ruby(schema["items"]))
+    elif type_ == "object":
+        if "additionalProperties" in schema:
+            return "Hash<String, {}>".format(
+                type_to_ruby(schema["additionalProperties"])
+            )
+        return (
+            alternative_name
+            if alternative_name
+            and (
+                "properties" in schema
+                or "oneOf" in schema
+                or "anyOf" in schema
+                or "allOf" in schema
+            )
+            else "Object"
+        )
+    elif type_ == "null":
+        return "nil"
+    else:
+        raise ValueError(f"Unknown type {type_}")
+
+
+def get_type_for_attribute(schema, attribute, current_name=None):
+    """Return Ruby type name for the attribute."""
+    child_schema = schema.get("properties", {}).get(attribute)
+    alternative_name = (
+        current_name + formatter.camel_case(attribute) if current_name else None
+    )
+    return type_to_ruby(child_schema, alternative_name=alternative_name)
+
+
+def get_type_for_parameter(parameter):
+    """Return Ruby type name for the parameter."""
+    if "content" in parameter:
+        assert "in" not in parameter
+        for content in parameter["content"].values():
+            return type_to_ruby(content["schema"])
+    return type_to_ruby(parameter.get("schema"))
+
+
+def child_models(schema, alternative_name=None, seen=None):
+    seen = seen or set()
+    current_name = get_name(schema)
+    name = current_name or alternative_name
+
+    has_sub_models = False
+    if "allOf" in schema:
+        has_sub_models = True
+        for child in schema["allOf"]:
+            yield from child_models(child, seen=seen)
+    if "oneOf" in schema:
+        has_sub_models = True
+        for child in schema["oneOf"]:
+            yield from child_models(child, seen=seen)
+    if "anyOf" in schema:
+        has_sub_models = True
+        for child in schema["anyOf"]:
+            yield from child_models(child, seen=seen)
+
+    if "items" in schema:
+        yield from child_models(
+            schema["items"],
+            alternative_name=alternative_name + "Item"
+            if alternative_name is not None
+            else None,
+            seen=seen,
+        )
+
+    if (
+        schema.get("type") == "object" or "properties" in schema or has_sub_models
+    ) and "additionalProperties" not in schema:
+        if not has_sub_models and name is None:
+            # this is a basic map object so we don't need a type
+            return
+
+        if name is None:
+            raise ValueError(f"Schema {schema} has no name")
+
+        if name in seen:
+            return
+
+        if "properties" in schema or has_sub_models:
+            seen.add(name)
+            yield name, schema
+
+        for key, child in schema.get("properties", {}).items():
+            yield from child_models(
+                child, alternative_name=name + formatter.camel_case(key), seen=seen
+            )
+
+    if "enum" in schema:
+        if name is None:
+            raise ValueError(f"Schema {schema} has no name")
+
+        if name in seen:
+            return
+
+        seen.add(name)
+        yield name, schema
+
+    if "additionalProperties" in schema:
+        nested_name = get_name(schema["additionalProperties"])
+        if nested_name:
+            yield from child_models(
+                schema["additionalProperties"],
+                alternative_name=name,
+                seen=seen,
+            )
+
+
+def models(spec):
+    name_to_schema = {}
+
+    for path in spec["paths"]:
+        for method in spec["paths"][path]:
+            operation = spec["paths"][path][method]
+
+            for content in operation.get("parameters", []):
+                if "schema" in content:
+                    name_to_schema.update(dict(child_models(content["schema"])))
+
+            for content in operation.get("requestBody", {}).get("content", {}).values():
+                if "schema" in content:
+                    name_to_schema.update(dict(child_models(content["schema"])))
+
+            for response in operation.get("responses", {}).values():
+                for content in response.get("content", {}).values():
+                    if "schema" in content:
+                        name_to_schema.update(dict(child_models(content["schema"])))
+
+    return name_to_schema
+
+
+def apis(spec):
+    operations = {}
+
+    for path in spec["paths"]:
+        for method in spec["paths"][path]:
+            operation = spec["paths"][path][method]
+            tag = operation.get("tags", [None])[0]
+            operations.setdefault(tag, []).append((path, method, operation))
+
+    return operations
+
+
+def operation(spec, operation_id):
+    for path in spec["paths"]:
+        for method in spec["paths"][path]:
+            operation = spec["paths"][path][method]
+            if operation["operationId"] == operation_id:
+                return operation
+    return None
+
+
+def parameters(operation):
+    for content in operation.get("parameters", []):
+        if "schema" in content:
+            yield content["name"], content
+
+    if "requestBody" in operation:
+        if "multipart/form-data" in operation["requestBody"]["content"]:
+            parent = operation["requestBody"]["content"]["multipart/form-data"]["schema"]
+            for name, schema in parent["properties"].items():
+                yield name, {
+                    "in": "form",
+                    "schema": schema,
+                    "name": name,
+                    "description": schema.get("description"),
+                    "required": name in parent.get("required", []),
+                }
+        else:
+            name = operation.get("x-codegen-request-body-name", "body")
+            yield name, operation["requestBody"]
+
+
+def parameter_schema(parameter):
+    if "schema" in parameter:
+        return parameter["schema"]
+    if "content" in parameter:
+        for content in parameter.get("content", {}).values():
+            if "schema" in content:
+                return content["schema"]
+    raise ValueError(f"Unknown schema for parameter {parameter}")
+
+
+def return_type(operation):
+    for response in operation.get("responses", {}).values():
+        for content in response.get("content", {}).values():
+            if "schema" in content:
+                return type_to_ruby(content["schema"])
+        return
+
+
+def accept_headers(operation):
+    any_type = "*/*"
+    seen = []
+    for response in operation.get("responses", {}).values():
+        if "content" in response:
+            for media_type in response["content"].keys():
+                if media_type not in seen:
+                    seen.append(media_type)
+        else:
+            return [any_type]
+    return seen
+
+
+def collection_format(parameter):
+    in_to_style = {
+        "query": "form",
+        "path": "simple",
+        "header": "simple",
+        "cookie": "form",
+    }
+    schema = parameter_schema(parameter)
+    matrix = {
+        ("form", False): "csv",
+        ("form", True): "multi",
+        # TODO add more cases from https://swagger.io/specification/#parameter-style
+    }
+    if (schema.get("type") == "array" or "items" in schema):
+        in_ = parameter.get("in", "query")
+        style = parameter.get("style", in_to_style[in_])
+        explode = parameter.get("explode", True if style == "form" else False)
+        return matrix.get((style, explode), "multi")
+
+
+def format_server(server, server_variables=None, path=""):
+    url = server["url"] + path
+    # replace potential path variables
+    for variable, value in (server_variables or {}).items():
+        url = url.replace("{" + variable + "}", value)
+    # replace server variables if they were not replace before
+    for variable in server["variables"]:
+        if server_variables and variable in server_variables:
+            continue
+        url = url.replace(
+            "{" + variable + "}", server["variables"][variable]["default"]
+        )
+    return urlparse(url)
+
+
+def server_url_and_method(spec, operation_id, server_index=0, server_variables=None):
+    for path in spec["paths"]:
+        for method in spec["paths"][path]:
+            operation = spec["paths"][path][method]
+            if operation["operationId"] == operation_id:
+                if "servers" in operation:
+                    server = operation["servers"][server_index]
+                else:
+                    server = spec["servers"][server_index]
+                return (
+                    format_server(
+                        server, server_variables=server_variables, path=path
+                    ).geturl(),
+                    method,
+                )
+
+    raise ValueError(f"Operation {operation_id} not found")
+
+
+def response_code_and_accept_type(operation, status_code=None):
+    for response in operation["responses"]:
+        if status_code is None:
+            return int(response), next(
+                iter(operation["responses"][response].get("content", {None: None}))
+            )
+        if response == str(status_code):
+            return status_code, next(
+                iter(operation["responses"][response].get("content", {None: None}))
+            )
+    return status_code, None
+
+
+def request_content_type(operation, status_code=None):
+    return next(iter(operation.get("requestBody", {}).get("content", {None: None})))
+
+
+def response(operation, status_code=None):
+    for response in operation["responses"]:
+        if status_code is None or response == str(status_code):
+            return list(operation["responses"][response]["content"].values())[0][
+                "schema"
+            ]
+    return None

data/.generator/src/generator/templates/api.j2

@@ -0,0 +1,223 @@
+=begin
+{% include "api_info.j2" %}
+=end
+
+require 'cgi'
+
+module {{ config.moduleName }}
+{%- set classname = name.replace(" ", "") + "API" %}
+  class {{ classname }}
+    attr_accessor :api_client
+
+    def initialize(api_client = APIClient.default)
+      @api_client = api_client
+    end
+
+{%- for path, method, operation in operations|sort(attribute="2.operationId") %}
+    {%- set httpMethod = method.upper() %}
+    {%- set returnType = operation|return_type %}
+
+    {{ operation.summary|block_comment|indent(4) }}
+    {%- if operation.description %}
+    {{ operation.description|block_comment|indent(4) }}
+    {%- endif %}
+    {%- for name, parameter in operation|parameters if parameter.required %}
+    # @param {{ name|attribute_name }} [{{ get_type_for_parameter(parameter) }}] {{ parameter.get("description", "").replace('\n', ' ') }}
+    {%- endfor %}
+    # @param opts [Hash] the optional parameters
+    {%- for name, parameter in operation|parameters if not parameter.required %}
+    # @option opts [{{ get_type_for_parameter(parameter) }}] :{{ name|attribute_name }} {{ parameter.get("description", "").replace('\n', ' ') }}{% if "default" in parameter%} (default to {{ parameter.default|format_value }}) {% endif %}
+    {%- endfor %}
+    # @return [{% if returnType %}{{ returnType }}{% else %}nil{% endif %}]
+    def {{ operation.operationId|snake_case }}({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts = {})
+      {% if returnType %}data, _status_code, _headers = {% endif %}{{ operation.operationId|snake_case }}_with_http_info({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts)
+      {% if returnType %}data{% else %}nil{% endif %}
+    end
+
+    {{ operation.summary|block_comment|indent(4) }}
+    {%- if operation.description %}
+    {{ operation.description|block_comment|indent(4) }}
+    {%- endif %}
+    {%- for name, parameter in operation|parameters if parameter.required %}
+    # @param {{ name|attribute_name }} [{{ get_type_for_parameter(parameter) }}] {{ parameter.get("description", "").replace('\n', ' ') }}
+    {%- endfor %}
+    # @param opts [Hash] the optional parameters
+    {%- for name, parameter in operation|parameters if not parameter.required %}
+    # @option opts [{{ get_type_for_parameter(parameter) }}] :{{ name|attribute_name }} {{ parameter.get("description", "").replace('\n', ' ') }}{% if "default" in parameter%} (default to {{ parameter.default|json }}) {% endif %}
+    {%- endfor %}
+    # @return [Array<({% if returnType %}{{ returnType }}{% else %}nil{% endif %}, Integer, Hash)>] {% if returnType %}{{ returnType }} data{% else %}nil{% endif %}, response status code and response headers
+    def {{ operation.operationId|snake_case }}_with_http_info({% for name, parameter in operation|parameters if parameter.required %}{{ name|attribute_name }}, {% endfor %}opts = {})
+
+      if @api_client.config.unstable_operations.has_key?(:{{ operation.operationId|snake_case }})
+        unstable_enabled = @api_client.config.unstable_operations[:{{ operation.operationId|snake_case }}]
+        if unstable_enabled
+          @api_client.config.logger.warn format("Using unstable operation '%s'", "{{ operation.operationId|snake_case }}")
+        else
+          raise APIError.new(message: format("Unstable operation '%s' is disabled", "{{ operation.operationId|snake_case }}"))
+        end
+      end
+
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: {{classname}}.{{ operation.operationId|snake_case }} ...'
+      end
+
+{%- for name, parameter in operation|parameters %}
+  {%- set schema = parameter|parameter_schema %}
+  {%- if parameter.required %}
+    {%- if not parameter.nullable %}
+      # verify the required parameter '{{ name|attribute_name }}' is set
+      if @api_client.config.client_side_validation && {{ name|attribute_name }}.nil?
+        fail ArgumentError, "Missing the required parameter '{{ name|attribute_name }}' when calling {{classname}}.{{ operation.operationId|snake_case }}"
+      end
+      {%- if schema.enum is defined and not parameter|collection_format %}
+      # verify enum value
+      allowable_values = [{% for value in schema.enum %}{{ value|format_value }}{%- if not loop.last %}, {% endif %}{% endfor %}]
+      if @api_client.config.client_side_validation && !allowable_values.include?({{ name|attribute_name }})
+        fail ArgumentError, "invalid value for \"{{ name|attribute_name }}\", must be one of #{allowable_values}"
+      end
+      {%- endif %}
+    {%- endif %}
+  {%- else %}
+    {%- if schema.enum is defined %}
+      allowable_values = [{% for value in schema.enum %}{{ value|format_value }}{%- if not loop.last %}, {% endif %}{% endfor %}]
+      {%- if parameter|collection_format %}
+      if @api_client.config.client_side_validation && opts[:'{{ name|attribute_name }}'] && !opts[:'{{ name|attribute_name }}'].all? { |item| allowable_values.include?(item) }
+        fail ArgumentError, "invalid value for \"{{ name|attribute_name }}\", must include one of #{allowable_values}"
+      end
+      {%- else %}
+      if @api_client.config.client_side_validation && opts[:'{{ name|attribute_name }}'] && !allowable_values.include?(opts[:'{{ name|attribute_name }}'])
+        fail ArgumentError, "invalid value for \"{{ name|attribute_name }}\", must be one of #{allowable_values}"
+      end
+      {%- endif %}
+    {%- endif %}
+
+  {%- endif %}
+  {%- if schema.maxLength is defined %}
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %}.to_s.length > {{ schema.maxLength }}
+        fail ArgumentError, 'invalid value for "{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:"{{ name|attribute_name }}"]{% endif %}" when calling {{classname}}.{{ operation.operationId|snake_case }}, the character length must be smaller than or equal to {{ schema.maxLength }}.'
+      end
+
+  {%- endif %}
+  {%- if schema.minLength is defined %}
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %}.to_s.length < {{ schema.minLength }}
+        fail ArgumentError, 'invalid value for "{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:"{{ name|attribute_name }}"]{% endif %}" when calling {{classname}}.{{ operation.operationId|snake_case }}, the character length must be great than or equal to {{ schema.minLength }}.'
+      end
+
+  {%- endif %}
+  {%- if schema.maximum is defined %}
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %} >{% if parameter.exclusiveMaximum %}={% endif %} {{ schema.maximum }}
+        fail ArgumentError, 'invalid value for "{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:"{{ name|attribute_name }}"]{% endif %}" when calling {{classname}}.{{ operation.operationId|snake_case }}, must be smaller than {% if not parameter.exclusiveMaximum %}or equal to {% endif %}{{ schema.maximum }}.'
+      end
+
+  {%- endif %}
+  {%- if schema.minimum is defined %}
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %} <{% if parameter.exclusiveMinimum %}={% endif %} {{ schema.minimum }}
+        fail ArgumentError, 'invalid value for "{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:"{{ name|attribute_name }}"]{% endif %}" when calling {{classname}}.{{ operation.operationId|snake_case }}, must be greater than {% if not parameter.exclusiveMinimum %}or equal to {% endif %}{{ schema.minimum }}.'
+      end
+
+  {%- endif %}
+  {%- if schema.pattern is defined %}
+      pattern = Regexp.new({{ schema.pattern }})
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %} !~ pattern
+        fail ArgumentError, "invalid value for '{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:\"{{ name|attribute_name }}\"]{% endif %}' when calling {{classname}}.{{ operation.operationId|snake_case }}, must conform to the pattern #{pattern}."
+      end
+
+  {%- endif %}
+  {%- if schema.maxItems is defined %}
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %}.length > {{ schema.maxItems }}
+        fail ArgumentError, 'invalid value for "{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:"{{ name|attribute_name }}"]{% endif %}" when calling {{classname}}.{{ operation.operationId|snake_case }}, number of items must be less than or equal to {{ schema.maxItems }}.'
+      end
+
+      {%- endif %}
+  {%- if schema.minItems is defined %}
+      if @api_client.config.client_side_validation && {% if not parameter.required %}!opts[:'{{ name|attribute_name }}'].nil? && {% endif %}{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:'{{ name|attribute_name }}']{% endif %}.length < {{ schema.minItems }}
+        fail ArgumentError, 'invalid value for "{% if parameter.required %}{{ name|attribute_name }}{% else %}opts[:"{{ name|attribute_name }}"]{% endif %}" when calling {{classname}}.{{ operation.operationId|snake_case }}, number of items must be greater than or equal to {{ schema.minItems }}.'
+      end
+
+  {%- endif %}
+{%- endfor %}
+      # resource path
+      local_var_path = '{{ path }}'{% for parameter in operation.parameters if parameter.in == "path" %}.sub('{{ '{' }}{{ parameter.name }}{{ '}'}}', CGI.escape({{ parameter.name }}.to_s).gsub('%2F', '/')){% endfor %}
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      {%- for name, parameter in operation|parameters if parameter.in == "query" and parameter.required %}
+      {%- set collection = parameter|collection_format %}
+      query_params[:'{{ name }}'] = {% if collection %}@api_client.build_collection_param({{ name|attribute_name }}, :{{ collection }}){% else %}{{ name|attribute_name }}{% endif %}
+      {%- endfor %}
+      {%- for name, parameter in operation|parameters if parameter.in == "query" and not parameter.required %}
+      {%- set collection = parameter|collection_format %}
+      query_params[:'{{ name }}'] = {% if collection %}@api_client.build_collection_param(opts[:'{{ name|attribute_name }}'], :{{ collection }}){% else %}opts[:'{{ name|attribute_name }}']{% endif %} if !opts[:'{{ name|attribute_name }}'].nil?
+      {%- endfor %}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      {%- if operation.responses %}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept([{% for mediaType in operation|accept_headers %}'{{ mediaType }}'{%- if not loop.last %}, {% endif %}{% endfor %}])
+      {%- endif %}
+
+      {%- if operation.requestBody %}
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type([{% for mediaType in operation.requestBody.content.keys() %}'{{ mediaType }}'{%- if not loop.last %}, {% endif %}{% endfor %}])
+      {%- endif %}
+
+      {%- for name, parameter in operation|parameters if parameter.in == "header" and parameter.required %}
+      {%- set collection = parameter|collection_format %}
+      header_params['{{ name }}'] = {% if collection %}@api_client.build_collection_param({{ name|attribute_name }}, :{{ collection }}){% else %}{ name|attribute_name }}{% endif %}
+      {%- endfor %}
+      {%- for name, parameter in operation|parameters if parameter.in == "header" and not parameter.required %}
+      {%- set collection = parameter|collection_format %}
+      header_params['{{ name }}'] = {% if collection %}@api_client.build_collection_param(opts[:'{{ name|attribute_name }}'], :{{ collection }}){% else %}opts[:'{{ name|attribute_name }}']{% endif %} if !opts[:'{{ name|attribute_name }}'].nil?
+      {%- endfor %}
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+      {%- for name, parameter in operation|parameters if parameter.in == "form" and parameter.required %}
+      {%- set collection = parameter|collection_format %}
+      form_params['{{ name }}'] = {% if collection %}@api_client.build_collection_param({{ name|attribute_name }}, :{{ collection }}){% else %}{{ name|attribute_name }}{% endif %}
+      {%- endfor %}
+      {%- for name, parameter in operation|parameters if parameter.in == "form" and not parameter.required %}
+      {%- set collection = parameter|collection_format %}
+      form_params['{{ name }}'] = {% if collection %}@api_client.build_collection_param(opts[:'{{ name|attribute_name }}'], :{{ collection }}){% else %}opts[:'{{ name|attribute_name }}']{% endif %} if !opts[:'{{ name|attribute_name }}'].nil?
+      {%- endfor %}
+
+      # http body (model)
+      post_body = opts[:debug_body]{% if operation.requestBody %} || @api_client.object_to_http_body(
+        {%- if operation.requestBody.required -%}
+        {{ operation.get("x-codegen-request-body-name", "body") }}
+        {%- else -%}
+        opts[:'{{ operation.get("x-codegen-request-body-name", "body") }}']
+        {%- endif -%}
+      ){% endif %}
+
+      # return_type
+      return_type = opts[:debug_return_type]{% if returnType %} || '{{ returnType }}'{% endif %}
+
+      # auth_names
+      {%- set authMethods = operation.security if "security" in operation else openapi.security %}
+      auth_names = opts[:debug_auth_names] || [{% for auth in (authMethods or []) %}:{{ ", :".join(auth.keys()) }}{%- if not loop.last %}, {% endif %}{% endfor %}]
+
+      new_options = opts.merge(
+        :operation => :{{ operation.operationId|snake_case }},
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:{{ httpMethod }}, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: {{ classname }}#{{ operation.operationId|snake_case }}\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+{%- if not loop.last %}
+
+{%- endif %}
+{%- endfor %}
+  end
+end
+{# keep new line at the end of file #}