packageruby 1.1.1

data/lib/form3_public_api/controllers/platformsecurityapi_controller.rb

@@ -0,0 +1,69 @@
+# form3_public_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Form3PublicApi
+  # PlatformsecurityapiController
+  class PlatformsecurityapiController < BaseController
+    # Get a list of Signing Keys
+    # @return [SigningKeysListResponse] response from the API call
+    def get_a_list_of_signing_keys
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/platform/security/signing_keys',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(SigningKeysListResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'Action Forbidden',
+                                ApiErrorException)
+                   .local_error('502',
+                                'Bad Gateway',
+                                ApiErrorException)
+                   .local_error('default',
+                                'Unexpected Error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Signing Key
+    # @param [UUID | String] signingkey_id Required parameter: Signing Key ID
+    # @return [SigningKeysResponse] response from the API call
+    def fetch_a_signing_key(signingkey_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/platform/security/signing_keys/{signingkey_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(signingkey_id, key: 'signingkey_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(SigningKeysResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'Action Forbidden',
+                                ApiErrorException)
+                   .local_error('404',
+                                'Not Found',
+                                ApiErrorException)
+                   .local_error('502',
+                                'Bad Gateway',
+                                ApiErrorException)
+                   .local_error('default',
+                                'Unexpected Error',
+                                ApiErrorException))
+        .execute
+    end
+  end
+end

data/lib/form3_public_api/controllers/query_api_controller.rb

@@ -0,0 +1,402 @@
+# form3_public_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Form3PublicApi
+  # QueryApiController
+  class QueryApiController < BaseController
+    # Get Query
+    # @param [Array[UUID | String]] filter_organisation_id Optional parameter:
+    # The organisations to filter on
+    # @param [ReportRequestStatusEnum] filter_status Optional parameter: Find
+    # all queries for a given status
+    # @param [String] filter_query_type Optional parameter: Find all queries for
+    # a given query type
+    # @param [TrueClass | FalseClass] filter_auto_handled Optional parameter:
+    # Find all queries for given auto handled flag
+    # @param [Date] filter_processing_date_from Optional parameter: Find all
+    # queries from a certain value date.
+    # @param [Date] filter_processing_date_to Optional parameter: Find all
+    # queries up to a certain value date.
+    # @param [DateTime] filter_created_on_from Optional parameter: Find all
+    # queries from a certain created date.
+    # @param [DateTime] filter_created_on_to Optional parameter: Find all
+    # queries up to a certain created date.
+    # @param [UUID | String] filter_payment_id Optional parameter: Find all
+    # queries with a certain payment id.
+    # @param [UUID | String] filter_payment_admission_id Optional parameter:
+    # Find all queries with a certain payment admission id.
+    # @param [UUID | String] filter_payment_submission_id Optional parameter:
+    # Find all queries with a certain payment submission id.
+    # @param [UUID | String] filter_recall_id Optional parameter: Find all
+    # queries with a certain recall id.
+    # @param [UUID | String] filter_recall_submission_id Optional parameter:
+    # Find all queries with a certain recall submission id.
+    # @param [UUID | String] filter_query_id Optional parameter: Find all
+    # queries with a certain query id.
+    # @param [String] page_number Optional parameter: Which page to select
+    # @param [Integer] page_size Optional parameter: Number of items to select
+    # @return [QueryListResponse] response from the API call
+    def list_queries(filter_organisation_id: nil,
+                     filter_status: nil,
+                     filter_query_type: nil,
+                     filter_auto_handled: nil,
+                     filter_processing_date_from: nil,
+                     filter_processing_date_to: nil,
+                     filter_created_on_from: nil,
+                     filter_created_on_to: nil,
+                     filter_payment_id: nil,
+                     filter_payment_admission_id: nil,
+                     filter_payment_submission_id: nil,
+                     filter_recall_id: nil,
+                     filter_recall_submission_id: nil,
+                     filter_query_id: nil,
+                     page_number: nil,
+                     page_size: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(filter_organisation_id, key: 'filter[organisation_id]'))
+                   .query_param(new_parameter(filter_status, key: 'filter[status]'))
+                   .query_param(new_parameter(filter_query_type, key: 'filter[query_type]'))
+                   .query_param(new_parameter(filter_auto_handled, key: 'filter[auto_handled]'))
+                   .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_created_on_from, key: 'filter[created_on_from]'))
+                   .query_param(new_parameter(filter_created_on_to, key: 'filter[created_on_to]'))
+                   .query_param(new_parameter(filter_payment_id, key: 'filter[payment.id]'))
+                   .query_param(new_parameter(filter_payment_admission_id, key: 'filter[payment_admission.id]'))
+                   .query_param(new_parameter(filter_payment_submission_id, key: 'filter[payment_submission.id]'))
+                   .query_param(new_parameter(filter_recall_id, key: 'filter[recall.id]'))
+                   .query_param(new_parameter(filter_recall_submission_id, key: 'filter[recall_submission.id]'))
+                   .query_param(new_parameter(filter_query_id, key: 'filter[query.id]'))
+                   .query_param(new_parameter(page_number, key: 'page[number]'))
+                   .query_param(new_parameter(page_size, key: 'page[size]'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(QueryListResponse.method(:from_hash))
+                   .local_error('400',
+                                'Query bad request',
+                                ApiErrorException)
+                   .local_error('502',
+                                'Query gateway issue',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Create a Query
+    # @param [QueryCreation] creation_request Optional parameter: Example:
+    # @return [QueryFetchResponse] response from the API call
+    def create_query(creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/queries',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(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(QueryFetchResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException)
+                   .local_error('502',
+                                'gateway issue',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Query
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @return [QueryFetchResponse] response from the API call
+    def get_query(query_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries/{query_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_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(QueryFetchResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Query Admission
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [UUID | String] query_admission_id Required parameter: Query
+    # Admission ID
+    # @return [QueryAdmissionResponse] response from the API call
+    def get_query_admission(query_id,
+                            query_admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries/{query_id}/admissions/{query_admission_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_admission_id, key: 'query_admission_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(QueryAdmissionResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Create a Query Response
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [QueryResponseCreation] creation_request Optional parameter:
+    # Example:
+    # @return [QueryResponseResponse] response from the API call
+    def create_query_response(query_id,
+                              creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/queries/{query_id}/responses',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(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(QueryResponseResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException)
+                   .local_error('502',
+                                'gateway issue',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Query Response
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [UUID | String] query_response_id Required parameter: Query
+    # Response ID
+    # @return [QueryResponseResponse] response from the API call
+    def get_query_response(query_id,
+                           query_response_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries/{query_id}/responses/{query_response_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_response_id, key: 'query_response_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(QueryResponseResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Query Response Admission
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [UUID | String] query_response_id Required parameter: Query
+    # Response ID
+    # @param [UUID | String] query_response_admission_id Required parameter:
+    # Query Response Admission ID
+    # @return [QueryResponseAdmissionResponse] response from the API call
+    def get_query_response_admission(query_id,
+                                     query_response_id,
+                                     query_response_admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries/{query_id}/responses/{query_response_id}/admissions/{query_response_admission_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_response_id, key: 'query_response_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_response_admission_id, key: 'query_response_admission_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(QueryResponseAdmissionResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Create a Query Response Submission
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [UUID | String] query_response_id Required parameter: Query
+    # Response ID
+    # @param [QueryResponseSubmissionCreation] creation_request Optional
+    # parameter: Example:
+    # @return [QueryResponseSubmissionResponse] response from the API call
+    def create_query_response_submission(query_id,
+                                         query_response_id,
+                                         creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/queries/{query_id}/responses/{query_response_id}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_response_id, key: 'query_response_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(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(QueryResponseSubmissionResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException)
+                   .local_error('502',
+                                'gateway issue',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Query Response Submission
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [UUID | String] query_response_id Required parameter: Query
+    # Response ID
+    # @param [UUID | String] query_response_submission_id Required parameter:
+    # Query Response Submission ID
+    # @return [QueryResponseSubmissionResponse] response from the API call
+    def get_query_response_submission(query_id,
+                                      query_response_id,
+                                      query_response_submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries/{query_id}/responses/{query_response_id}/submissions/{query_response_submission_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_response_id, key: 'query_response_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_response_submission_id, key: 'query_response_submission_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(QueryResponseSubmissionResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Create a Query submission
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [QuerySubmissionCreation] creation_request Optional parameter:
+    # Example:
+    # @return [QuerySubmissionResponse] response from the API call
+    def create_query_submission(query_id,
+                                creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/queries/{query_id}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(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(QuerySubmissionResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException)
+                   .local_error('502',
+                                'gateway issue',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch a Query submission
+    # @param [UUID | String] query_id Required parameter: Query ID
+    # @param [UUID | String] query_submission_id Required parameter: Query
+    # Submission ID
+    # @return [QuerySubmissionResponse] response from the API call
+    def get_query_submission(query_id,
+                             query_submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/queries/{query_id}/submissions/{query_submission_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(query_id, key: 'query_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(query_submission_id, key: 'query_submission_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(QuerySubmissionResponse.method(:from_hash))
+                   .local_error('400',
+                                'bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'forbidden',
+                                ApiErrorException))
+        .execute
+    end
+  end
+end

data/lib/form3_public_api/controllers/reports_controller.rb

@@ -0,0 +1,139 @@
+# form3_public_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Form3PublicApi
+  # ReportsController
+  class ReportsController < BaseController
+    # List reports
+    # @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 Ids
+    # @param [String] filter_report_type Optional parameter: Filter by
+    # ReportType
+    # @param [String] filter_report_type_description Optional parameter: Filter
+    # by Report Type Description
+    # @param [String] filter_report_source Optional parameter: Filter by Report
+    # Source
+    # @param [DateTime] filter_created_on_after Optional parameter: Request
+    # reports created after specific date time
+    # @param [DateTime] filter_created_on_before Optional parameter: Request
+    # reports created after specific date time
+    # @param [DateTime] filter_modified_on_after Optional parameter: Request
+    # reports modified after specific date time
+    # @param [DateTime] filter_modified_on_before Optional parameter: Request
+    # reports modified before specific date time
+    # @param [Date] filter_processing_date_from Optional parameter: Request
+    # reports with processing date from specific date (inclusive)
+    # @param [Date] filter_processing_date_to Optional parameter: Request
+    # reports with processing date to specific date (inclusive)
+    # @return [ReportDetailsListResponse] response from the API call
+    def list_reports(page_number: nil,
+                     page_size: 100,
+                     filter_organisation_id: nil,
+                     filter_report_type: nil,
+                     filter_report_type_description: nil,
+                     filter_report_source: nil,
+                     filter_created_on_after: nil,
+                     filter_created_on_before: nil,
+                     filter_modified_on_after: nil,
+                     filter_modified_on_before: nil,
+                     filter_processing_date_from: nil,
+                     filter_processing_date_to: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/notification/reports',
+                                     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_report_type, key: 'filter[report_type]'))
+                   .query_param(new_parameter(filter_report_type_description, key: 'filter[report_type_description]'))
+                   .query_param(new_parameter(filter_report_source, key: 'filter[report_source]'))
+                   .query_param(new_parameter(filter_created_on_after, key: 'filter[created_on_after]'))
+                   .query_param(new_parameter(filter_created_on_before, key: 'filter[created_on_before]'))
+                   .query_param(new_parameter(filter_modified_on_after, key: 'filter[modified_on_after]'))
+                   .query_param(new_parameter(filter_modified_on_before, key: 'filter[modified_on_before]'))
+                   .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]'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReportDetailsListResponse.method(:from_hash))
+                   .local_error('400',
+                                'Reports bad request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Get report by ID
+    # @param [UUID | String] id Required parameter: Report ID
+    # @param [String] accept Required parameter: Acceptable Format
+    # @return [ReportDetailsResponse] response from the API call
+    def get_report(id,
+                   accept)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/notification/reports/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(accept, key: 'Accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReportDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                ApiErrorException)
+                   .local_error('404',
+                                'Report Not Found',
+                                ApiErrorException)
+                   .local_error('406',
+                                'Report not available in acceptable format',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Get Report Admission by ID
+    # @param [UUID | String] id Required parameter: Report Id
+    # @param [UUID | String] admission_id Required parameter: Report Admission
+    # ID
+    # @return [ReportAdmissionDetailsResponse] response from the API call
+    def get_report_admission_by_id(id,
+                                   admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/notification/reports/{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(ReportAdmissionDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Bad Request',
+                                ApiErrorException)
+                   .local_error('403',
+                                'Forbidden',
+                                ApiErrorException)
+                   .local_error('404',
+                                'Not Found',
+                                ApiErrorException))
+        .execute
+    end
+  end
+end