card-management-sdk 1.0.0 → 1.2.0

data/lib/shell_card_management_ap_is/controllers/customer_controller.rb

@@ -17,16 +17,16 @@ module ShellCardManagementApIs
     # @param [String] request_id Required parameter: Mandatory UUID (according
     # to RFC 4122 standards) for requests and responses. This will be played
     # back in the response from the request.
-    # @param [LoggedInUserRequest] body Optional parameter: Logged in user
-    # request body
-    # @return [LoggedInUserResponse] response from the API call
-    def loggedin_user(apikey,
-                      request_id,
-                      body: nil)
+    # @param [FleetmanagementV1UserLoggedinuserRequest] body Optional parameter:
+    # Logged in user request body
+    # @return [LoggedInUserResponse] response from the API call.
+    def loggedinuser(apikey,
+                     request_id,
+                     body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/user/loggedinuser',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -35,31 +35,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(LoggedInUserResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(LoggedInUserResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 FleetmanagementV1UserLoggedinuser400ErrorException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 FleetmanagementV1UserLoggedinuser401ErrorException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 FleetmanagementV1UserLoggedinuser403ErrorException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 FleetmanagementV1UserLoggedinuser404ErrorException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 FleetmanagementV1UserLoggedinuser500ErrorException))
         .execute
     end
 
@@ -79,14 +79,14 @@ module ShellCardManagementApIs
     # back in the response from the request.
     # @param [PayerRequest] body Optional parameter: Serach payers request
     # body
-    # @return [PayerResponse] response from the API call
+    # @return [PayerResponse] response from the API call.
     def payers(apikey,
                request_id,
                body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/payers',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -95,31 +95,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(PayerResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PayerResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 FleetmanagementV1CustomerPayers400ErrorException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 FleetmanagementV1CustomerPayers404ErrorException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -133,14 +133,14 @@ module ShellCardManagementApIs
     # back in the response from the request.
     # @param [CustomerDetailRequest] body Optional parameter: Customerdetails
     # request body
-    # @return [CustomerDetailResponse] response from the API call
+    # @return [CustomerDetailResponse] response from the API call.
     def customer(apikey,
                  request_id,
                  body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/customer',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -149,31 +149,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(CustomerDetailResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CustomerDetailResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 FleetmanagementV1CustomerCustomer403ErrorException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -186,14 +186,14 @@ module ShellCardManagementApIs
     # to RFC 4122 standards) for requests and responses. This will be played
     # back in the response from the request.
     # @param [AccountRequest] body Optional parameter: Example:
-    # @return [AccountResponse] response from the API call
+    # @return [AccountResponse] response from the API call.
     def accounts(apikey,
                  request_id,
                  body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/accounts',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -202,31 +202,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(AccountResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AccountResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -239,14 +239,14 @@ module ShellCardManagementApIs
     # back in the response from the request.
     # @param [CardTypeRequest] body Optional parameter: Get CardType Request
     # Body
-    # @return [CardTypeResponse] response from the API call
+    # @return [CardTypeResponse] response from the API call.
     def card_type(apikey,
                   request_id,
                   body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v2/customer/cardtype',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -255,31 +255,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(CardTypeResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CardTypeResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -299,14 +299,14 @@ module ShellCardManagementApIs
     # to RFC 4122 standards) for requests and responses. This will be played
     # back in the response from the request.
     # @param [CardGroupRequest] body Optional parameter: Request Body
-    # @return [CardGroupResponse] response from the API call
-    def card_groups(apikey,
-                    request_id,
-                    body: nil)
+    # @return [CardGroupResponse] response from the API call.
+    def cardgroups(apikey,
+                   request_id,
+                   body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/cardgroups',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -315,31 +315,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(CardGroupResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CardGroupResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -359,8 +359,7 @@ module ShellCardManagementApIs
     # * BCOSummary
     # * BCOMultiAccountSummary
     # * BCBSummary
-    # * Mobile Payment
-    # * Registration
+    # * Mobile Payment Registration
     # * Fund Transfer (Scheduled & Realtime)
     # * Delivery Address Update.
     # @param [String] apikey Required parameter: This is the API key of the
@@ -369,14 +368,14 @@ module ShellCardManagementApIs
     # to RFC 4122 standards) for requests and responses. This will be played
     # back in the response from the request.
     # @param [AuditRequest] body Optional parameter: request body
-    # @return [AuditResponse] response from the API call
-    def audit_report(apikey,
-                     request_id,
-                     body: nil)
+    # @return [AuditResponse] response from the API call.
+    def auditreport(apikey,
+                    request_id,
+                    body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/auditreport',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -385,31 +384,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(AuditResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AuditResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -432,14 +431,14 @@ module ShellCardManagementApIs
     # back in the response from the request.
     # @param [CreateCardGroupRequest] body Optional parameter: CreateCardGroup
     # request body
-    # @return [CreateCardGroupResponse] response from the API call
-    def create_card_group(apikey,
-                          request_id,
-                          body: nil)
+    # @return [CreateCardGroupResponse] response from the API call.
+    def createcardgroup(apikey,
+                        request_id,
+                        body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/createcardgroup',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -448,31 +447,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(CreateCardGroupResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateCardGroupResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
 
@@ -491,14 +490,14 @@ module ShellCardManagementApIs
     # back in the response from the request.
     # @param [UpdateCardGroupRequest] body Optional parameter: request body of
     # customer card group
-    # @return [UpdateCardGroupResponse] response from the API call
-    def update_card_group(apikey,
-                          request_id,
-                          body: nil)
+    # @return [UpdateCardGroupResponse] response from the API call.
+    def updatecardgroup(apikey,
+                        request_id,
+                        body: nil)
       new_api_call_builder
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/fleetmanagement/v1/customer/updatecardgroup',
-                                     Server::DEFAULT)
+                                     Server::SHELL)
                    .header_param(new_parameter(apikey, key: 'apikey'))
                    .header_param(new_parameter(request_id, key: 'RequestId'))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
@@ -507,31 +506,31 @@ module ShellCardManagementApIs
                    .body_serializer(proc do |param| param.to_json unless param.nil? end)
                    .auth(Single.new('BasicAuth')))
         .response(new_response_handler
-                   .deserializer(APIHelper.method(:custom_type_deserializer))
-                   .deserialize_into(UpdateCardGroupResponse.method(:from_hash))
-                   .local_error('400',
-                                "The server cannot or will not process the request  due to'\
-                                 ' something that is perceived to be a client\r\n error (e.g.,'\
-                                 ' malformed request syntax, invalid \r\n request message framing,'\
-                                 ' or deceptive request routing).",
-                                DefaultErrorException)
-                   .local_error('401',
-                                "The request has not been applied because it lacks valid '\
-                                 ' authentication credentials for the target resource.\r\n",
-                                DefaultErrorException)
-                   .local_error('403',
-                                "The server understood the request but refuses to authorize it.'\
-                                 '\r\n",
-                                ErrorUserAccessError1Exception)
-                   .local_error('404',
-                                "The origin server did not find a current representation  for'\
-                                 ' the target resource or is not willing to disclose  that one'\
-                                 ' exists.\r\n",
-                                DefaultErrorException)
-                   .local_error('500',
-                                "The server encountered an unexpected condition the prevented it'\
-                                 ' from fulfilling the request.\r\n",
-                                DefaultErrorException))
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateCardGroupResponse.method(:from_hash))
+                    .local_error('400',
+                                 "The server cannot or will not process the request  due to'\
+                                  ' something that is perceived to be a client\r\n error (e.g.,'\
+                                  ' malformed request syntax, invalid \r\n request message'\
+                                  ' framing, or deceptive request routing).",
+                                 APIException)
+                    .local_error('401',
+                                 'The request has not been applied because it lacks valid '\
+                                  ' authentication credentials for the target resource.',
+                                 APIException)
+                    .local_error('403',
+                                 'The server understood the request but refuses to authorize it'\
+                                  '.',
+                                 APIException)
+                    .local_error('404',
+                                 'The origin server did not find a current representation  for'\
+                                  ' the target resource or is not willing to disclose  that one'\
+                                  ' exists.',
+                                 APIException)
+                    .local_error('500',
+                                 'The server encountered an unexpected condition the prevented'\
+                                  ' it from fulfilling the request.',
+                                 APIException))
         .execute
     end
   end