apimatic-pnl-sdk 1.0.0

data/lib/postnl_ecommerce/controllers/checkout_controller.rb

@@ -0,0 +1,45 @@
+# postnl_ecommerce
+#
+# This file was automatically generated for PostNL by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PostnlEcommerce
+  # CheckoutController
+  class CheckoutController < BaseController
+    # TODO: type endpoint description here
+    # @param [CheckoutRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def checkout(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/shipment/v1/checkout',
+                                     Server::POSTNL)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CheckoutResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+  end
+end

data/lib/postnl_ecommerce/controllers/confirming_controller.rb

@@ -0,0 +1,45 @@
+# postnl_ecommerce
+#
+# This file was automatically generated for PostNL by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PostnlEcommerce
+  # ConfirmingController
+  class ConfirmingController < BaseController
+    # TODO: type endpoint description here
+    # @param [ConfirmingRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def confirm_shipment(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/shipment/v2/confirm',
+                                     Server::POSTNL)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ConfirmingResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Error payload',
+                                 ConfirmingResponseErrorException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+  end
+end

data/lib/postnl_ecommerce/controllers/deliverydate_controller.rb

@@ -0,0 +1,233 @@
+# postnl_ecommerce
+#
+# This file was automatically generated for PostNL by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PostnlEcommerce
+  # DeliverydateController
+  class DeliverydateController < BaseController
+    # Request example:
+    # ```
+    # curl -X GET
+    # "https://api-sandbox.postnl.nl/shipment/v2_2/calculate/date/delivery?Shipp
+    # ingDate=29-05-2022+14%3A00%3A00&amp;ShippingDuration=1&amp;CutOffTime=17%3
+    # A00%3A00&amp;PostalCode=2132WT&amp;CountryCode=NL&amp;City=Hoofddorp&amp;S
+    # treet=Siriusdreef&amp;HouseNumber=42&amp;HouseNrExt=A" \
+    #  -H "Accept: application/json" \
+    #  -H "apikey: APIKEY-HERE"
+    # ```
+    # @param [String] shipping_date Required parameter: Date/time of preparing
+    # the shipment for sending. Format: dd-MM-yyyy hh:mm:ss
+    # @param [Integer] shipping_duration Required parameter: The duration it
+    # takes for the shipment to be delivered to PostNL in days. A value of 1
+    # means that the parcel will be delivered to PostNL on the same day as the
+    # date specified in ShippingDate. A value of 2 means the parcel will arrive
+    # at PostNL a day later etc.
+    # @param [String] cut_off_time Required parameter: Default cutoff time
+    # @param [String] postal_code Required parameter: Zipcode of the destination
+    # address
+    # @param [CountrycodeEnum] country_code Required parameter: The ISO2
+    # destination country code
+    # @param [Array[DeliverydateOptionEnum]] options Required parameter: The
+    # delivery options that you want to take into account when calculating the
+    # expected delivery date
+    # @param [OriginCountryCodeEnum] origin_country_code Optional parameter: The
+    # ISO2 origin country code
+    # @param [String] city Optional parameter: City of the destination address
+    # @param [String] street Optional parameter: The street name of the
+    # destination address.
+    # @param [Integer] house_number Optional parameter: The house number of the
+    # destination address
+    # @param [String] house_nr_ext Optional parameter: House number extension of
+    # the delivery address
+    # @param [String] cut_off_time_monday Optional parameter: Overrides default
+    # cutoff time specified in the CutOffTime parameter for mondays
+    # specifically
+    # @param [TrueClass | FalseClass] available_monday Optional parameter:
+    # Specifies if you are available to ship to PostNL on mondays
+    # @param [String] cut_off_time_tuesday Optional parameter: Overrides default
+    # cutoff time specified in the CutOffTime parameter for tuesdays
+    # specifically
+    # @param [TrueClass | FalseClass] available_tuesday Optional parameter:
+    # Specifies if you are available to ship to PostNL on tuesdays
+    # @param [String] cut_off_time_wednesday Optional parameter: Overrides
+    # default cutoff time specified in the CutOffTime parameter for wednesdays
+    # specifically
+    # @param [TrueClass | FalseClass] available_wednesday Optional parameter:
+    # Specifies if you are available to ship to PostNL on wednesdays
+    # @param [String] cut_off_time_thursday Optional parameter: Overrides
+    # default cutoff time specified in the CutOffTime parameter for thursdays
+    # specifically
+    # @param [TrueClass | FalseClass] available_thursday Optional parameter:
+    # Specifies if you are available to ship to PostNL on thursdays
+    # @param [String] cut_off_time_friday Optional parameter: Overrides default
+    # cutoff time specified in the CutOffTime parameter for fridays
+    # specifically
+    # @param [TrueClass | FalseClass] available_friday Optional parameter:
+    # Specifies if you are available to ship to PostNL on fridays
+    # @param [String] cut_off_time_saturday Optional parameter: Overrides
+    # default cutoff time specified in the CutOffTime parameter for saturdays
+    # specifically
+    # @param [TrueClass | FalseClass] available_saturday Optional parameter:
+    # Specifies if you are available to ship to PostNL on saturdays
+    # @param [String] cut_off_time_sunday Optional parameter: Overrides default
+    # cutoff time specified in the CutOffTime parameter for sundays
+    # specifically
+    # @param [TrueClass | FalseClass] available_sunday Optional parameter:
+    # Specifies if you are available to ship to PostNL on sundays
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def calculate_delivery_date(shipping_date,
+                                shipping_duration,
+                                cut_off_time,
+                                postal_code,
+                                country_code,
+                                options,
+                                origin_country_code: OriginCountryCodeEnum::NL,
+                                city: nil,
+                                street: nil,
+                                house_number: nil,
+                                house_nr_ext: nil,
+                                cut_off_time_monday: nil,
+                                available_monday: nil,
+                                cut_off_time_tuesday: nil,
+                                available_tuesday: nil,
+                                cut_off_time_wednesday: nil,
+                                available_wednesday: nil,
+                                cut_off_time_thursday: nil,
+                                available_thursday: nil,
+                                cut_off_time_friday: nil,
+                                available_friday: nil,
+                                cut_off_time_saturday: nil,
+                                available_saturday: nil,
+                                cut_off_time_sunday: nil,
+                                available_sunday: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/shipment/v2_2/calculate/date/delivery',
+                                     Server::POSTNL)
+                   .query_param(new_parameter(shipping_date, key: 'ShippingDate'))
+                   .query_param(new_parameter(shipping_duration, key: 'ShippingDuration'))
+                   .query_param(new_parameter(cut_off_time, key: 'CutOffTime'))
+                   .query_param(new_parameter(postal_code, key: 'PostalCode'))
+                   .query_param(new_parameter(country_code, key: 'CountryCode'))
+                   .query_param(new_parameter(options, key: 'Options'))
+                   .query_param(new_parameter(origin_country_code, key: 'OriginCountryCode'))
+                   .query_param(new_parameter(city, key: 'City'))
+                   .query_param(new_parameter(street, key: 'Street'))
+                   .query_param(new_parameter(house_number, key: 'HouseNumber'))
+                   .query_param(new_parameter(house_nr_ext, key: 'HouseNrExt'))
+                   .query_param(new_parameter(cut_off_time_monday, key: 'CutOffTimeMonday'))
+                   .query_param(new_parameter(available_monday, key: 'AvailableMonday'))
+                   .query_param(new_parameter(cut_off_time_tuesday, key: 'CutOffTimeTuesday'))
+                   .query_param(new_parameter(available_tuesday, key: 'AvailableTuesday'))
+                   .query_param(new_parameter(cut_off_time_wednesday, key: 'CutOffTimeWednesday'))
+                   .query_param(new_parameter(available_wednesday, key: 'AvailableWednesday'))
+                   .query_param(new_parameter(cut_off_time_thursday, key: 'CutOffTimeThursday'))
+                   .query_param(new_parameter(available_thursday, key: 'AvailableThursday'))
+                   .query_param(new_parameter(cut_off_time_friday, key: 'CutOffTimeFriday'))
+                   .query_param(new_parameter(available_friday, key: 'AvailableFriday'))
+                   .query_param(new_parameter(cut_off_time_saturday, key: 'CutOffTimeSaturday'))
+                   .query_param(new_parameter(available_saturday, key: 'AvailableSaturday'))
+                   .query_param(new_parameter(cut_off_time_sunday, key: 'CutOffTimeSunday'))
+                   .query_param(new_parameter(available_sunday, key: 'AvailableSunday'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DeliverydateDeliveryResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+
+    # Request example:
+    # ```
+    # curl -X GET
+    # "https://api-sandbox.postnl.nl/shipment/v2_2/calculate/date/shipping?Deliv
+    # eryDate=30-05-2022&amp;ShippingDuration=1&amp;PostalCode=2132WT&amp;Countr
+    # yCode=NL&amp;City=Hoofddorp&amp;Street=Siriusdreef&amp;HouseNumber=42&amp;
+    # HouseNrExt=A" \
+    #  -H "Accept: application/json" \
+    #  -H "apikey: APIKEY-HERE" \
+    # ```
+    # @param [String] delivery_date Required parameter: Date of the expected
+    # delivery (to the final destination) of the shipment.
+    # @param [Integer] shipping_duration Required parameter: The duration it
+    # takes for the shipment to be delivered to PostNL in days. A value of 1
+    # means that the parcel will be delivered to PostNL on the same day as the
+    # date specified in ShippingDate. A value of 2 means the parcel will arrive
+    # at PostNL a day later etc.
+    # @param [String] postal_code Required parameter: Zipcode of the address
+    # @param [CountrycodeEnum] country_code Required parameter: The ISO2
+    # destination country code
+    # @param [OriginCountryCodeEnum] origin_country_code Optional parameter: The
+    # ISO2 country code of the origin country
+    # @param [String] city Optional parameter: City of the destination address
+    # @param [String] street Optional parameter: The street name of the
+    # destination address
+    # @param [Integer] house_number Optional parameter: The house number of the
+    # destination address
+    # @param [String] house_nr_ext Optional parameter: House number extension of
+    # the destination address
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def calculate_shipping_date(delivery_date,
+                                shipping_duration,
+                                postal_code,
+                                country_code,
+                                origin_country_code: OriginCountryCodeEnum::NL,
+                                city: nil,
+                                street: nil,
+                                house_number: nil,
+                                house_nr_ext: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/shipment/v2_2/calculate/date/shipping',
+                                     Server::POSTNL)
+                   .query_param(new_parameter(delivery_date, key: 'DeliveryDate'))
+                   .query_param(new_parameter(shipping_duration, key: 'ShippingDuration'))
+                   .query_param(new_parameter(postal_code, key: 'PostalCode'))
+                   .query_param(new_parameter(country_code, key: 'CountryCode'))
+                   .query_param(new_parameter(origin_country_code, key: 'OriginCountryCode'))
+                   .query_param(new_parameter(city, key: 'City'))
+                   .query_param(new_parameter(street, key: 'Street'))
+                   .query_param(new_parameter(house_number, key: 'HouseNumber'))
+                   .query_param(new_parameter(house_nr_ext, key: 'HouseNrExt'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DeliverydateShippingResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+  end
+end

data/lib/postnl_ecommerce/controllers/labelling_controller.rb

@@ -0,0 +1,52 @@
+# postnl_ecommerce
+#
+# This file was automatically generated for PostNL by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PostnlEcommerce
+  # LabellingController
+  class LabellingController < BaseController
+    # TODO: type endpoint description here
+    # @param [LabellingRequest] body Required parameter: TODO: type description
+    # here
+    # @param [TrueClass | FalseClass] confirm Optional parameter: With the
+    # Confirm boolean in the request, you can determine if you want to confirm
+    # the shipment in the same call or not. If the Boolean variable is true the
+    # shipment will be preannounced. If this is set to false, then an additional
+    # Confirming API request needs to be made.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def generate_label(body,
+                       confirm: true)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/shipment/v2_2/label',
+                                     Server::POSTNL)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .query_param(new_parameter(confirm, key: 'confirm'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(LabellingResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Error payload',
+                                 LabellingResponseInvalidException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+  end
+end

data/lib/postnl_ecommerce/controllers/locations_controller.rb

@@ -0,0 +1,271 @@
+# postnl_ecommerce
+#
+# This file was automatically generated for PostNL by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PostnlEcommerce
+  # LocationsController
+  class LocationsController < BaseController
+    # Request example:
+    # ```
+    # curl -X GET
+    # "https://api-sandbox.postnl.nl/shipment/v2_1/locations/nearest?CountryCode
+    # =NL&PostalCode=2132WT&City=Hoofddorp&Street=Siriusdreef&HouseNumber=42&Hou
+    # seNumberExtension=-60&DeliveryDate=24-12-2022&OpeningTime=09%3A00%3A00" \
+    #  -H "Accept: application/json" \
+    #  -H "apikey: APIKEY-HERE" \
+    # ```
+    # @param [CountrycodeEnum] country_code Required parameter: The country of
+    # the recipient's address
+    # @param [String] postal_code Required parameter: The zipcode of the
+    # recipient's address
+    # @param [String] city Optional parameter: The city of the recipient's
+    # address
+    # @param [String] street Optional parameter: The street name of the
+    # recipient's address
+    # @param [Integer] house_number Optional parameter: The house number of the
+    # recipient's address
+    # @param [String] house_number_extension Optional parameter: The house
+    # number extension of the recipient's address
+    # @param [String] delivery_date Optional parameter: The date of the earliest
+    # delivery date at the pickup location. Format:  dd-MM-yyyy. Note: this date
+    # cannot be in the past, otherwise an error is returned. If not provided,
+    # the present day is used as a default
+    # @param [String] opening_time Optional parameter: Opening time filter.
+    # Format: hh:mm:ss. This field will be used to filter out locations that are
+    # closed at the time provided. If no opening time is provided all locations
+    # will be returned regardless of their opening times.
+    # @param [Array[LocationsDeliveryOptionEnum]] delivery_options Optional
+    # parameter: The pickup location types for which locations should be
+    # filtered. By default all location types are returned (PG = Retail points
+    # and parcel lockers). This can be used to filter on only parcel lockers
+    # (PA) or specifically exclude parcel lockers from the response (PG_EX).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_pickup_locations_by_address(country_code,
+                                        postal_code,
+                                        city: nil,
+                                        street: nil,
+                                        house_number: nil,
+                                        house_number_extension: nil,
+                                        delivery_date: nil,
+                                        opening_time: nil,
+                                        delivery_options: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/shipment/v2_1/locations/nearest',
+                                     Server::POSTNL)
+                   .query_param(new_parameter(country_code, key: 'CountryCode'))
+                   .query_param(new_parameter(postal_code, key: 'PostalCode'))
+                   .query_param(new_parameter(city, key: 'City'))
+                   .query_param(new_parameter(street, key: 'Street'))
+                   .query_param(new_parameter(house_number, key: 'HouseNumber'))
+                   .query_param(new_parameter(house_number_extension, key: 'HouseNumberExtension'))
+                   .query_param(new_parameter(delivery_date, key: 'DeliveryDate'))
+                   .query_param(new_parameter(opening_time, key: 'OpeningTime'))
+                   .query_param(new_parameter(delivery_options, key: 'DeliveryOptions'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(LocationsResponseMultiple.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+
+    # Request example:
+    # ```
+    # curl -X GET
+    # "https://api-sandbox.postnl.nl/shipment/v2_1/locations/nearest/geocode?Lat
+    # itude=52.2864669620795&Longitude=4.68239055845954&CountryCode=NL&DeliveryD
+    # ate=24-12-2022&OpeningTime=09%3A00%3A00" \
+    #  -H "Accept: application/json" \
+    #  -H "apikey: APIKEY-HERE" \
+    # ```
+    # @param [Float] latitude Required parameter: The latitude of the location
+    # @param [Float] longitude Required parameter: The longitude of the
+    # location
+    # @param [CountrycodeEnum] country_code Required parameter: The coutry for
+    # which the coordinates are provided
+    # @param [String] delivery_date Optional parameter: The date of the earliest
+    # delivery date. Format:  dd-MM-yyyy. Note: this date cannot be in the past,
+    # otherwise an error is returned.
+    # @param [String] opening_time Optional parameter: Opening time filter.
+    # Format: hh:mm:ss. This field will be used to filter out locations that are
+    # closed at the time provided.
+    # @param [Array[LocationsDeliveryOptionEnum]] delivery_options Optional
+    # parameter: The pickup location types for which locations should be
+    # filtered. By default all location types are returned (PG = Retail points
+    # and parcel lockers). This can be used to filter on only parcel lockers
+    # (PA) or specifically exclude parcel lockers from the response (PG_EX).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_pickup_locations_by_coordinates(latitude,
+                                            longitude,
+                                            country_code,
+                                            delivery_date: nil,
+                                            opening_time: nil,
+                                            delivery_options: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/shipment/v2_1/locations/nearest/geocode',
+                                     Server::POSTNL)
+                   .query_param(new_parameter(latitude, key: 'Latitude'))
+                   .query_param(new_parameter(longitude, key: 'Longitude'))
+                   .query_param(new_parameter(country_code, key: 'CountryCode'))
+                   .query_param(new_parameter(delivery_date, key: 'DeliveryDate'))
+                   .query_param(new_parameter(opening_time, key: 'OpeningTime'))
+                   .query_param(new_parameter(delivery_options, key: 'DeliveryOptions'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(LocationsResponseMultiple.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+
+    # Request example:
+    # ```
+    # curl -X GET
+    # "https://api-sandbox.postnl.nl/shipment/v2_1/locations/area?LatitudeNorth=
+    # 52.156439&LongitudeWest=5.015643&LatitudeSouth=52.017473&LongitudeEast=5.0
+    # 65254&CountryCode=NL&DeliveryDate=24-12-2023&OpeningTime=09%3A00%3A00" \
+    #  -H "Accept: application/json" \
+    #  -H "apikey: APIKEY-HERE" \
+    # ```
+    # @param [Float] latitude_north Required parameter: The northmost
+    # coordinates of the area
+    # @param [Float] longitude_west Required parameter: The westmost coordinates
+    # of the area
+    # @param [Float] latitude_south Required parameter: The southmost
+    # coordinates of the area
+    # @param [Float] longitude_east Required parameter: The eastmost coordinates
+    # of the area
+    # @param [CountrycodeEnum] country_code Required parameter: Example:
+    # @param [String] delivery_date Optional parameter: The date of the earliest
+    # delivery date. Format:  dd-MM-yyyy. Note: this date cannot be in the past,
+    # otherwise an error is returned.
+    # @param [String] opening_time Optional parameter: Opening time filter.
+    # Format: hh:mm:ss. This field will be used to filter out locations that are
+    # closed at the time provided.
+    # @param [Array[LocationsDeliveryOptionEnum]] delivery_options Optional
+    # parameter: The pickup location types for which locations should be
+    # filtered. By default all location types are returned (PG = Retail points
+    # and parcel lockers). This can be used to filter on only parcel lockers
+    # (PA) or specifically exclude parcel lockers from the response (PG_EX).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_pickup_locations_within_area(latitude_north,
+                                         longitude_west,
+                                         latitude_south,
+                                         longitude_east,
+                                         country_code,
+                                         delivery_date: nil,
+                                         opening_time: nil,
+                                         delivery_options: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/shipment/v2_1/locations/area',
+                                     Server::POSTNL)
+                   .query_param(new_parameter(latitude_north, key: 'LatitudeNorth'))
+                   .query_param(new_parameter(longitude_west, key: 'LongitudeWest'))
+                   .query_param(new_parameter(latitude_south, key: 'LatitudeSouth'))
+                   .query_param(new_parameter(longitude_east, key: 'LongitudeEast'))
+                   .query_param(new_parameter(country_code, key: 'CountryCode'))
+                   .query_param(new_parameter(delivery_date, key: 'DeliveryDate'))
+                   .query_param(new_parameter(opening_time, key: 'OpeningTime'))
+                   .query_param(new_parameter(delivery_options, key: 'DeliveryOptions'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(LocationsResponseMultiple.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+
+    # Request example:
+    # ```
+    # curl -X GET
+    # "https://api-sandbox.postnl.nl/shipment/v2_1/locations/lookup?LocationCode
+    # =216877" \
+    #  -H "Accept: application/json" \
+    #  -H "apikey: APIKEY-HERE"
+    # ```
+    # @param [String] location_code Required parameter: LocationCode
+    # information
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_pickup_location(location_code)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/shipment/v2_1/locations/lookup',
+                                     Server::POSTNL)
+                   .query_param(new_parameter(location_code, key: 'LocationCode'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyHeader')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(LocationResponseSingle.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Invalid request',
+                                 InvalidRequestException)
+                    .local_error('401',
+                                 'Invalid apikey',
+                                 UnauthorizedException)
+                    .local_error('405',
+                                 'Method not allowed',
+                                 MethodNotAllowedOnlyGetPostException)
+                    .local_error('429',
+                                 'Too many requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal server error',
+                                 InternalServerErrorException))
+        .execute
+    end
+  end
+end