packageruby 1.1.1

data/lib/form3_public_api/controllers/mandates_controller.rb

@@ -0,0 +1,372 @@
+# form3_public_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Form3PublicApi
+  # MandatesController
+  class MandatesController < BaseController
+    # List mandates
+    # @param [String] page_number Optional parameter: Which page to select
+    # @param [Integer] page_size Optional parameter: Number of items to select
+    # @param [Array[UUID | String]] filter_organisation_id Optional parameter:
+    # Filter by organisation id
+    # @param [String] filter_debtor_party_account_number Optional parameter:
+    # Example:
+    # @param [String] filter_debtor_party_bank_id Optional parameter: Example:
+    # @param [String] filter_beneficiary_party_account_number Optional
+    # parameter: Example:
+    # @param [String] filter_beneficiary_party_bank_id Optional parameter:
+    # Example:
+    # @param [String] filter_currency Optional parameter: Example:
+    # @param [String] filter_payment_scheme Optional parameter: Example:
+    # @param [String] filter_scheme_payment_type Optional parameter: Example:
+    # @param [Date] filter_processing_date_from Optional parameter: Example:
+    # @param [Date] filter_processing_date_to Optional parameter: Example:
+    # @param [Date] filter_scheme_processing_date_from Optional parameter:
+    # Example:
+    # @param [Date] filter_scheme_processing_date_to Optional parameter:
+    # Example:
+    # @param [String] filter_clearing_id Optional parameter: Example:
+    # @param [DateTime] filter_admission_admission_date_from Optional parameter:
+    # Example:
+    # @param [DateTime] filter_admission_admission_date_to Optional parameter:
+    # Example:
+    # @param [String] filter_admission_status Optional parameter: Filter by
+    # admission status
+    # @param [String] filter_admission_scheme_status_code Optional parameter:
+    # Filter by admission scheme status code
+    # @param [String] filter_amount Optional parameter: Filter by amount
+    # @param [String] filter_reference Optional parameter: Filter by reference
+    # @param [String] filter_unique_scheme_id Optional parameter: Filter by
+    # unique scheme id
+    # @param [TrueClass | FalseClass] filter_all_versions Optional parameter:
+    # Include old versions of mandates
+    # @param [DateTime] filter_submission_submission_date_from Optional
+    # parameter: Example:
+    # @param [DateTime] filter_submission_submission_date_to Optional parameter:
+    # Example:
+    # @param [String] filter_status Optional parameter: Filter by mandate
+    # status
+    # @param [String] filter_status_reason Optional parameter: Filter by mandate
+    # status reason
+    # @return [MandateDetailsListResponse] response from the API call
+    def get_mandates(page_number: nil,
+                     page_size: nil,
+                     filter_organisation_id: nil,
+                     filter_debtor_party_account_number: nil,
+                     filter_debtor_party_bank_id: nil,
+                     filter_beneficiary_party_account_number: nil,
+                     filter_beneficiary_party_bank_id: nil,
+                     filter_currency: nil,
+                     filter_payment_scheme: nil,
+                     filter_scheme_payment_type: nil,
+                     filter_processing_date_from: nil,
+                     filter_processing_date_to: nil,
+                     filter_scheme_processing_date_from: nil,
+                     filter_scheme_processing_date_to: nil,
+                     filter_clearing_id: nil,
+                     filter_admission_admission_date_from: nil,
+                     filter_admission_admission_date_to: nil,
+                     filter_admission_status: nil,
+                     filter_admission_scheme_status_code: nil,
+                     filter_amount: nil,
+                     filter_reference: nil,
+                     filter_unique_scheme_id: nil,
+                     filter_all_versions: nil,
+                     filter_submission_submission_date_from: nil,
+                     filter_submission_submission_date_to: nil,
+                     filter_status: nil,
+                     filter_status_reason: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/mandates',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(page_number, key: 'page[number]'))
+                   .query_param(new_parameter(page_size, key: 'page[size]'))
+                   .query_param(new_parameter(filter_organisation_id, key: 'filter[organisation_id]'))
+                   .query_param(new_parameter(filter_debtor_party_account_number, key: 'filter[debtor_party.account_number]'))
+                   .query_param(new_parameter(filter_debtor_party_bank_id, key: 'filter[debtor_party.bank_id]'))
+                   .query_param(new_parameter(filter_beneficiary_party_account_number, key: 'filter[beneficiary_party.account_number]'))
+                   .query_param(new_parameter(filter_beneficiary_party_bank_id, key: 'filter[beneficiary_party.bank_id]'))
+                   .query_param(new_parameter(filter_currency, key: 'filter[currency]'))
+                   .query_param(new_parameter(filter_payment_scheme, key: 'filter[payment_scheme]'))
+                   .query_param(new_parameter(filter_scheme_payment_type, key: 'filter[scheme_payment_type]'))
+                   .query_param(new_parameter(filter_processing_date_from, key: 'filter[processing_date_from]'))
+                   .query_param(new_parameter(filter_processing_date_to, key: 'filter[processing_date_to]'))
+                   .query_param(new_parameter(filter_scheme_processing_date_from, key: 'filter[scheme_processing_date_from]'))
+                   .query_param(new_parameter(filter_scheme_processing_date_to, key: 'filter[scheme_processing_date_to]'))
+                   .query_param(new_parameter(filter_clearing_id, key: 'filter[clearing_id]'))
+                   .query_param(new_parameter(filter_admission_admission_date_from, key: 'filter[admission.admission_date_from]'))
+                   .query_param(new_parameter(filter_admission_admission_date_to, key: 'filter[admission.admission_date_to]'))
+                   .query_param(new_parameter(filter_admission_status, key: 'filter[admission.status]'))
+                   .query_param(new_parameter(filter_admission_scheme_status_code, key: 'filter[admission.scheme_status_code]'))
+                   .query_param(new_parameter(filter_amount, key: 'filter[amount]'))
+                   .query_param(new_parameter(filter_reference, key: 'filter[reference]'))
+                   .query_param(new_parameter(filter_unique_scheme_id, key: 'filter[unique_scheme_id]'))
+                   .query_param(new_parameter(filter_all_versions, key: 'filter[all_versions]'))
+                   .query_param(new_parameter(filter_submission_submission_date_from, key: 'filter[submission.submission_date_from]'))
+                   .query_param(new_parameter(filter_submission_submission_date_to, key: 'filter[submission.submission_date_to]'))
+                   .query_param(new_parameter(filter_status, key: 'filter[status]'))
+                   .query_param(new_parameter(filter_status_reason, key: 'filter[status_reason]'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateDetailsListResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create Mandate
+    # @param [MandateCreation] mandate_creation_request Optional parameter:
+    # Example:
+    # @return [MandateCreationResponse] response from the API call
+    def post_mandates(mandate_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/mandates',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(mandate_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Mandate creation error',
+                                ApiErrorException)
+                   .local_error('409',
+                                'Mandate creation conflict Error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch mandate
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @return [MandateDetailsResponse] response from the API call
+    def get_mandates_id(id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/mandates/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Update mandate
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [MandateAmendment] mandate_amendment Optional parameter: Example:
+    # @return [MandateDetailsResponse] response from the API call
+    def patch_mandates_id(id,
+                          mandate_amendment: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/transaction/mandates/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(mandate_amendment))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Mandate update error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch Mandate Admission
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [UUID | String] admission_id Required parameter: Mandate Admission
+    # Id
+    # @return [MandateAdmissionDetailsResponse] response from the API call
+    def get_mandates_id_admissions_admission_id(id,
+                                                admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/mandates/{id}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create mandate return
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [MandateReturnCreation] return_creation_request Optional parameter:
+    # Example:
+    # @return [MandateReturnCreationResponse] response from the API call
+    def post_mandates_id_returns(id,
+                                 return_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/mandates/{id}/returns',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(return_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateReturnCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Return creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch mandate return
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @return [MandateReturnDetailsResponse] response from the API call
+    def get_mandates_id_returns_return_id(id,
+                                          return_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/mandates/{id}/returns/{returnId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateReturnDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create mandate return submission
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [MandateReturnSubmissionCreation]
+    # return_submission_creation_request Optional parameter: Example:
+    # @return [MandateReturnSubmissionCreationResponse] response from the API call
+    def post_mandates_id_returns_return_id_submissions(id,
+                                                       return_id,
+                                                       return_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/mandates/{id}/returns/{returnId}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(return_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateReturnSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Return submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch return submission
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [MandateReturnSubmissionDetailsResponse] response from the API call
+    def get_mandates_id_returns_return_id_submissions_submission_id(id,
+                                                                    return_id,
+                                                                    submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/mandates/{id}/returns/{returnId}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateReturnSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create Mandate Submission
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [MandateSubmissionCreation] mandate_submission_creation_request
+    # Optional parameter: Example:
+    # @return [MandateSubmissionDetailsResponse] response from the API call
+    def post_mandates_id_submissions(id,
+                                     mandate_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/mandates/{id}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(mandate_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateSubmissionDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Mandate Submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch Mandate Submission
+    # @param [UUID | String] id Required parameter: Mandate Id
+    # @param [UUID | String] submission_id Required parameter: Mandate
+    # Submission Id
+    # @return [MandateSubmissionDetailsResponse] response from the API call
+    def get_mandates_id_submissions_submission_id(id,
+                                                  submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/mandates/{id}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MandateSubmissionDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Error',
+                                ApiErrorException))
+        .execute
+    end
+  end
+end

data/lib/form3_public_api/controllers/metrics_api_controller.rb

@@ -0,0 +1,193 @@
+# form3_public_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Form3PublicApi
+  # MetricsAPIController
+  class MetricsAPIController < BaseController
+    # Query Endpoint for metrics
+    # @param [String] query Required parameter: Query to Execute
+    # @param [String] time Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] timeout Optional parameter: See
+    # https://prometheus.io/docs/prometheus/latest/querying/basics/#time-duratio
+    # ns
+    # @return [MetricsQueryResponse] response from the API call
+    def query_endpoint_for_metrics(query,
+                                   time: nil,
+                                   timeout: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/metrics/prometheus/api/v1/query',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(query, key: 'query'))
+                   .query_param(new_parameter(time, key: 'time'))
+                   .query_param(new_parameter(timeout, key: 'timeout'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MetricsQueryResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                MetricsQueryResponseErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                APIException)
+                   .local_error('500',
+                                'Internal Server Error',
+                                APIException))
+        .execute
+    end
+
+    # Query Endpoint for metrics
+    # @param [String] query Required parameter: Query to Execute
+    # @param [String] time Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] timeout Optional parameter: See
+    # https://prometheus.io/docs/prometheus/latest/querying/basics/#time-duratio
+    # ns
+    # @return [MetricsQueryResponse] response from the API call
+    def query_endpoint_for_metrics1(query,
+                                    time: nil,
+                                    timeout: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/metrics/prometheus/api/v1/query',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(query, key: 'query'))
+                   .form_param(new_parameter(time, key: 'time'))
+                   .form_param(new_parameter(timeout, key: 'timeout'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MetricsQueryResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                MetricsQueryResponseErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                APIException)
+                   .local_error('500',
+                                'Internal Server Error',
+                                APIException))
+        .execute
+    end
+
+    # Query Range Endpoint for metrics
+    # @param [String] query Required parameter: Query to Execute
+    # @param [String] time Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] timeout Optional parameter: See
+    # https://prometheus.io/docs/prometheus/latest/querying/basics/#time-duratio
+    # ns
+    # @param [String] start Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] mend Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] step Optional parameter: duration or float
+    # @return [MetricsQueryResponse] response from the API call
+    def query_range_endpoint_for_metrics(query,
+                                         time: nil,
+                                         timeout: nil,
+                                         start: nil,
+                                         mend: nil,
+                                         step: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/metrics/prometheus/api/v1/query_range',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(query, key: 'query'))
+                   .query_param(new_parameter(time, key: 'time'))
+                   .query_param(new_parameter(timeout, key: 'timeout'))
+                   .query_param(new_parameter(start, key: 'start'))
+                   .query_param(new_parameter(mend, key: 'end'))
+                   .query_param(new_parameter(step, key: 'step'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MetricsQueryResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                MetricsQueryResponseErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                APIException)
+                   .local_error('500',
+                                'Internal Server Error',
+                                APIException))
+        .execute
+    end
+
+    # Query Range Endpoint for metrics
+    # @param [String] query Required parameter: Query to Execute
+    # @param [String] time Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] timeout Optional parameter: See
+    # https://prometheus.io/docs/prometheus/latest/querying/basics/#time-duratio
+    # ns
+    # @param [String] start Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] mend Optional parameter: RFC3339 or unix_timestamp
+    # @param [String] step Optional parameter: duration or float
+    # @return [MetricsQueryResponse] response from the API call
+    def query_range_endpoint_for_metrics1(query,
+                                          time: nil,
+                                          timeout: nil,
+                                          start: nil,
+                                          mend: nil,
+                                          step: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/metrics/prometheus/api/v1/query_range',
+                                     Server::DEFAULT)
+                   .form_param(new_parameter(query, key: 'query'))
+                   .form_param(new_parameter(time, key: 'time'))
+                   .form_param(new_parameter(timeout, key: 'timeout'))
+                   .form_param(new_parameter(start, key: 'start'))
+                   .form_param(new_parameter(mend, key: 'end'))
+                   .form_param(new_parameter(step, key: 'step'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(MetricsQueryResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                MetricsQueryResponseErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                APIException)
+                   .local_error('500',
+                                'Internal Server Error',
+                                APIException))
+        .execute
+    end
+
+    # Federate Endpoint for metrics
+    # @param [Array[String]] match Required parameter: See
+    # https://prometheus.io/docs/prometheus/latest/querying/basics/#instant-vect
+    # or-selectors
+    # @return [String] response from the API call
+    def federate_endpoint_for_metrics(match)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/metrics/prometheus/federate',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(match, key: 'match'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:deserialize_primitive_types))
+                   .deserialize_into(proc do |response| response.to_s end)
+                   .is_primitive_response(true)
+                   .local_error('400',
+                                'Bad Request',
+                                MetricsQueryResponseErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                APIException)
+                   .local_error('500',
+                                'Internal Server Error',
+                                APIException))
+        .execute
+    end
+  end
+end