Class: UspsApi::ResourcesApi

Inherits:

BaseApi

Object
BaseApi
UspsApi::ResourcesApi

show all

Defined in:: lib/usps_api/apis/resources_api.rb

Overview

ResourcesApi

Constant Summary

Constants inherited from BaseApi

BaseApi::GLOBAL_ERRORS

Instance Attribute Summary

Attributes inherited from BaseApi

#config, #http_call_back

Instance Method Summary collapse

#delete_campaigns(scope, crid, campaign_id) ⇒ ApiResponse

Cancel a previously existing Informed Delivery campaign determines the level of access and permissions for the API.
#delete_carrier_pickup_confirmation_number(scope, confirmation_number, if_match) ⇒ ApiResponse

Cancel a previously scheduled carrier pick up.
#delete_containers_with_container_id(scope, container_id) ⇒ ApiResponse

In the context of container tracking, deleting all tracking numbers from a container results in an empty container, which allows for the addition of new tracking numbers.
#delete_containers_with_container_id_with_packages(scope, container_id, tracking_number) ⇒ ApiResponse

In the context of container tracking, deleting one tracking number from a container.
#delete_fast_appointment(scope, body: nil) ⇒ ApiResponse

Cancel Appointment Request provides the ability to cancel an appointment.
#delete_indicia_imb(scope, imb, x_payment_authorization_token) ⇒ ApiResponse

Cancel an Intelligent Mail Barcode (IMB) label for First-Class letters, flats, and cards or submit a refund request by providing the IMB.
#delete_international_label(scope, tracking_number, x_payment_authorization_token) ⇒ ApiResponse

Cancel a label or submit a refund request by providing the label’s tracking number.
#delete_label(scope, tracking_number, x_payment_authorization_token) ⇒ ApiResponse

Cancel a label or submit a refund request by providing the label’s tracking number.
#delete_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ ApiResponse

Delete a label branding image associated with your customer reference ID (CRID).
#delete_package_campaigns(scope, crid, campaign_id) ⇒ ApiResponse

Cancel a previously existing Informed Delivery package campaign determines the level of access and permissions for the API.
#delete_subscriptions_adjustment_id(scope, subscription_id, if_match) ⇒ ApiResponse

Use this endpoint to delete a Subscription by its unique identifier.
#delete_subscriptions_dispute_id(scope, subscription_id, if_match) ⇒ ApiResponse

Use this endpoint to delete a Subscription by its unique identifier.
#delete_subscriptions_ncoa_id(scope, subscription_id, if_match) ⇒ ApiResponse

Use this endpoint to delete a Subscription by its unique identifier.
#delete_subscriptions_package_transaction_details_id(scope, subscription_id, if_match) ⇒ ApiResponse

Use this endpoint to delete a Subscription by its unique identifier.
#delete_subscriptions_tracking_id(scope, subscription_id, if_match) ⇒ ApiResponse

Use this endpoint to delete a Subscription by its unique identifier.
#delete_subscriptions_unpaid_packages_id(scope, subscription_id, if_match) ⇒ ApiResponse

Use this endpoint to delete a Subscription by its unique identifier.
#get_address(scope, street_address, state, firm: nil, secondary_address: nil, city: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ ApiResponse

Standardizes street addresses including city and street abbreviations as well as providing missing information such as ZIP Code™ and ZIP + 4®.
#get_addresses(scope, street_address, firm_name: nil, secondary_address: nil, city: nil, state: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ ApiResponse

Standardizes street addresses including city and street abbreviations as well as providing missing information such as ZIP Code™ and ZIP + 4®.
#get_adjustments(scope, crid, tracking_number, event_type, destination_zip_code: nil) ⇒ ApiResponse

The Adjustments API enables users to receive USPS Ship adjustments by a Package Identification Code (PIC) aka Tracking Number.
#get_appointment_availability(scope, body: nil) ⇒ ApiResponse

Allows customers to check for appointment slots at the requested facility.
#get_campaigns(scope, crid, campaign_id) ⇒ ApiResponse

Return a single Informed Delivery campaign for a given Submitter CRID and Campaign ID determines the level of access and permissions for the API.
#get_campaigns1(scope, crid, offset: 0, limit: 100, sort: nil, ezsearch: nil, barcode_count: nil, brand_display_name: nil, campaign_code: nil, campaign_grouping_code: nil, mid: nil, campaign_title: nil, created_datetime: nil, end_date: nil, last_modified_datetime: nil, mail_owner_crid: nil, mail_owner_name: nil, start_date: nil, status: nil, submitted_datetime: nil) ⇒ ApiResponse

Search, filter, sort, and paginate package campaigns for a given Submitter CRID determines the level of access and permissions for the API.
#get_campaigns_callback(scope, crid, offset: 0, limit: 100, sort: nil, campaign_id: nil, submitted_datetime: nil, total_barcodes: nil, total_barcodes_added: nil, total_barcodes_failed: nil) ⇒ ApiResponse

Search all callback keys for Add Many IMB transactions performed by given Submitter CRID determines the level of access and permissions for the API.
#get_carrier_pickup_confirmation_number(scope, confirmation_number) ⇒ ApiResponse

Get the previously scheduled carrier pickup by confirmation number.
#get_carrier_pickup_eligibility(scope, street_address, secondary_address: nil, city: nil, state: nil, zip_code: nil, zip_plus4: nil, urbanization: nil) ⇒ ApiResponse

Check carrier pickup service availability at the specified address.
#get_city_state(scope, zip_code) ⇒ ApiResponse

Returns the city and state corresponding to the given ZIP Code™.
#get_coa_records_search(scope, body) ⇒ ApiResponse

Returns a list of records for a person’s current and old addresses.
#get_code(scope_template, response_type, client_id, redirect_uri, user_id, scope: nil, state: nil) ⇒ ApiResponse

The client application identifier and redirect URI are configured during client application registration.
#get_detail_data(scope, crid, callback_key, offset: 0, limit: 10, sort: nil, error_message: nil) ⇒ ApiResponse

Return IMB-level errors for a single callback key transaction determines the level of access and permissions for the API.
#get_dropoff_location(scope, destination_zip_code, destination_zip_plus4: nil, mail_class: nil, processing_category: nil, destination_entry_facility_type: nil, palletized: nil, mailing_date: nil) ⇒ ApiResponse

The Drop Off Location API can be used to find convenient USPS® entry facilities for destination entry volume.
#get_enrollment(scope, body: nil) ⇒ ApiResponse

Allows customers to get the USPS Ship enrollment status of a MID.
#get_international_base_rates_search(scope, body: nil) ⇒ ApiResponse

Given a set of SSF or scan-based rate ingredients, returns a international rates.
#get_international_extra_service_rates_search(scope, body: nil) ⇒ ApiResponse

Given a set of rate ingredients, returns international extra service rates.
#get_international_service_standard(scope, country_code, mail_class) ⇒ ApiResponse

Retrieve the service standard message based on the provided country code and mail class.
#get_list_label_branding(scope, x_payment_authorization_token, limit: 10, offset: 0, order_by: OrderBy::DESC, sort_by: SortBy::CREATEDDATETIME) ⇒ ApiResponse

Retrieve a paginated list of label branding images associated with your customer reference ID (CRID).
#get_package_tracking(tracking_number, scope, x_forwarded_for: nil, expand: Expand::SUMMARY, destination_zip_code: nil, mailing_date: nil) ⇒ ApiResponse

This API allows users to retrieve either a summary or detailed information about a specific USPS® package.
#get_parcel_locker_location(scope, city: nil, state: nil, zip_code: nil, offset: 0, limit: 30) ⇒ ApiResponse

The Parcel Locker Locations API can be used to search for operational USPS Parcel Locker locations by city/state combination or ZIP code.
#get_payment_account_account_number(scope, account_number, account_type, permit_zip_code: nil, amount: nil) ⇒ ApiResponse

You can check if sufficient funds exist in the account, if you pass the amount parameter.
#get_post_office_location(scope, street_address: nil, secondary_address: nil, city: nil, state: nil, urbanization: nil, zip_code: nil, zip_plus4: nil, lat: nil, long: nil, post_office_type: nil, mailing_service: nil, business_service: nil, passport_service: nil, pickup_service: nil, financial_service: nil, hours: nil, radius: 20, length: nil, width: nil, height: nil, offset: nil, limit: 20) ⇒ ApiResponse

A complete query consists of one of the following: * Complete domestic address * City/State Pair * ZIP Code™ * Latitude/Longitude pair Users can provide additional filters such as a radius (distance and units, defaults to 20 miles), location type, desired services, open times, and package dimensions.
#get_rate_list(scope, body: nil) ⇒ ApiResponse

Given size/weight/destination of pieces, returns a list of potential rates.
#get_reconciliation_adjustments(scope, crid, event_type, start_date, start_time, end_date, end_time, page_num: 20, page_size: 20) ⇒ ApiResponse

The Reconciliation Adjustments API enables users to receive USPS Ship adjustments by a Package Identification Code (PIC) aka Tracking Number.
#get_return_valid_zip5_codes(scope) ⇒ ApiResponse

**Return valid 5-digit Origin and Destination ZIP codes that have service standards associated with them and are not exempt.
#get_service_standards(scope, origin_zip_code, destination_zip_code, mail_class: nil, destination_type: DestinationType::STREET, service_type_codes: nil, destination_entry_facility_type: nil, weight: nil, length: nil, height: nil, width: nil, dimensions_uom: DimensionsUom::ENUM_IN, rate_holder_crid: nil, presort: false) ⇒ ApiResponse

Returns the average number of days it will take a package to arrive at its destination for the selected mail class.
#get_service_standards_estimates(scope, origin_zip_code, destination_zip_code, acceptance_date: nil, acceptance_time: nil, mail_class: nil, destination_type: DestinationType::STREET, service_type_codes: nil, destination_entry_facility_type: nil, weight: nil, weight_uom: WeightUom::LB, length: nil, height: nil, width: nil, dimensions_uom: DimensionsUom::ENUM_IN, rate_holder_crid: nil, presort: false) ⇒ ApiResponse

Allows customers to get estimates on delivery standards between 3 or 5 digit ZIP Code™s for the selected mail classes.
#get_single_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ ApiResponse

Retrieve a label branding image associated with your customer reference ID (CRID).
#get_single_package_campaign(scope, crid, campaign_id) ⇒ ApiResponse

Retrieve details of a single Informed Delivery package campaign by CRID and campaign ID determines the level of access and permissions for the API.
#get_subscriptions_adjustment(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

Get list of all Adjustment Subscriptions you have created, by CRID determines the level of access and permissions for the API.
#get_subscriptions_adjustment_id(scope, subscription_id) ⇒ ApiResponse

Get a previously created subscription by its unique id.
#get_subscriptions_dispute(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

Get list of all Disputes Subscriptions you have created, by CRID determines the level of access and permissions for the API.
#get_subscriptions_dispute_id(scope, subscription_id) ⇒ ApiResponse

Get a previously created subscription by its unique id.
#get_subscriptions_ncoa(scope, crid: nil, offset: nil, limit: 20) ⇒ ApiResponse

Get list of all NCOA Subscriptions you have created, by CRID.
#get_subscriptions_ncoa_id(scope, subscription_id) ⇒ ApiResponse

Get a previously created subscription by its unique id.
#get_subscriptions_package_transaction_details(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

Get list of all Package Transaction Details Subscriptions you have created, by CRID determines the level of access and permissions for the API.
#get_subscriptions_package_transaction_details_id(scope, subscription_id) ⇒ ApiResponse

Get a previously created subscription by its unique id.
#get_subscriptions_tracking(scope, mid: nil, tracking_number: nil, offset: nil, limit: 20) ⇒ ApiResponse

Get list of all Tracking Subscriptions you have created, by MID or Tracking Number.
#get_subscriptions_tracking_id(scope, subscription_id) ⇒ ApiResponse

Get a previously created subscription by its unique id.
#get_subscriptions_unpaid_packages(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

“Get list of all Unpaid Packages Subscriptions you have created, by CRID” determines the level of access and permissions for the API.
#get_subscriptions_unpaid_packages_id(scope, subscription_id) ⇒ ApiResponse

Get a previously created subscription by its unique id.
#get_summary_data(scope, crid, callback_key) ⇒ ApiResponse

Return summary-level information on a single callback key transaction determines the level of access and permissions for the API.
#get_user_profile(scope) ⇒ ApiResponse

Get user account profile information.
#get_zip_code(scope, street_address, city, state, firm: nil, secondary_address: nil, zip_code: nil, zip_plus4: nil) ⇒ ApiResponse

Returns the ZIP Code™ and ZIP + 4® corresponding to the given address, city, and state (use USPS state abbreviations).
#patch_label_branding(scope, image_uuid, x_payment_authorization_token, body) ⇒ ApiResponse

Rename the previously uploaded Label Branding Image associated with your customer reference ID (CRID).
#patch_label_edit(scope, tracking_number, x_payment_authorization_token, body) ⇒ ApiResponse

Allow customers to edit package attributes for previously created labels including weight, dimensions, rate indicator, processing category and containers.
#post_add_imb(scope, crid, campaign_id, body) ⇒ ApiResponse

Add IMBs to an existing NON-SEQ campaign determines the level of access and permissions for the API.
#post_base_rates_search(scope, body: nil) ⇒ ApiResponse

Returns an eligible price given a set of package rate ingredients.
#post_campaigns(scope, crid, body) ⇒ ApiResponse

Create a new Informed Delivery campaign determines the level of access and permissions for the API.
#post_campaigns1(scope, crid, body) ⇒ ApiResponse

Create a new Informed Delivery package campaign determines the level of access and permissions for the API.
#post_carrier_pickup(scope, body) ⇒ ApiResponse

Schedule a carrier pickup on a specified date.
#post_close(scope, x_payment_authorization_token, container_id, body) ⇒ ApiResponse

Allows the caller to close a container and generate a manifest.
#post_containers(scope, body: nil) ⇒ ApiResponse

Allows the caller to get a container label and associate packages to that container.
#post_containers_with_container_id(scope, container_id, body: nil) ⇒ ApiResponse

This endpoint allows the caller to add additional items to an already created container.
#post_dispute(body) ⇒ ApiResponse

Returns a dispute request details.
#post_extra_service_rates_search(scope, body: nil) ⇒ ApiResponse

Returns eligible extra service prices, descriptions, and SKUs given a set of package rate ingredients.
#post_fast_appointment(scope, body: nil) ⇒ ApiResponse

Create Appointment Request provides the ability to create an appointment.
#post_get_user_profile(scope) ⇒ ApiResponse

Get user account profile information.
#post_indicia_imb(scope, x_payment_authorization_token, body) ⇒ ApiResponse

Generates an Intelligent Mail Barcode (IMB) label for First-Class letters, flats, and cards.
#post_international_indicia(scope, x_payment_authorization_token, body) ⇒ ApiResponse

Generates a First-Class Mail International indicia for use on letter, flat, and cards mailings.
#post_international_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ ApiResponse

Generates a international shipping label based upon the input dimensions requested: | Element | Description | | —————————– | ——–| | toAddress | International destination address of the recipient.
#post_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ ApiResponse

Generates a shipping label based upon the following: | Element | Description | | —————————– | ——–| | toAddress | Address where the package is being shipped to.
#post_label_branding(scope, x_payment_authorization_token, body) ⇒ ApiResponse

The USPS Logo Branding endpoint allows you to upload your custom image or logo to USPS APIs.
#post_label_indicia(scope, x_payment_authorization_token, body) ⇒ ApiResponse

Generates a First-Class indicia for use on letter, flat, or card mailings.
#post_label_reprint(scope, tracking_number, x_payment_authorization_token, body) ⇒ ApiResponse

Reprint an international shipping label.
#post_label_reprint1(scope, tracking_number, x_payment_authorization_token, body) ⇒ ApiResponse

Reprint a Domestic Outbound or Domestic Return shipping label.
#post_letter_rates_search(scope, body: nil) ⇒ ApiResponse

Returns an eligible price given a set of letter rate ingredients for First-Class Mail.
#post_letter_rates_search1(scope, body: nil) ⇒ ApiResponse

Returns an eligible price given a set of letter rate ingredients for First-Class Mail International.
#post_manifest(scope, body: nil) ⇒ ApiResponse

Allows the caller to close a container and generate a manifest.
#post_options_search(scope, body) ⇒ ApiResponse

Based on the inputs below, the API generates a comprehensive list of shipping options that comply with USPS Shipping Standards, all within a single request.
#post_package_tracking_notifications(tracking_number, scope, body, x_forwarded_for: nil) ⇒ ApiResponse

By registering for the USPS® Tracking by Email service, users can receive email notifications about their package tracking events.
#post_payments_payment_authorization(scope, body: nil) ⇒ ApiResponse

Create a payment authorization token that can be subsequently used for purchasing labels.
#post_pmod(scope, x_payment_authorization_token, body) ⇒ ApiResponse

Create a new Open and Distribute container with the associated attributes from the request body.
#post_qrcode_search(scope, body: nil) ⇒ ApiResponse

The QR Code API enables shippers and integrators to request and receive QR codes for packages addressed to USPS lockers upon delivery.
#post_rate_list(scope, body: nil) ⇒ ApiResponse

Returns a list of eligible prices given dimensions/weight/destination of pieces.
#post_return_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ ApiResponse

Generates a returns shipping label based upon the input dimensions requested.
#post_return_service_standards_directory(scope, body) ⇒ ApiResponse

**Request Directory of Service Standards**: Return service standard data.
#post_revoke(scope, token, token_type_hint: TokenTypeHint::REFRESH_TOKEN) ⇒ ApiResponse

Prevent tokens from being further used to access APIs by invalidating OAuth tokens which are no longer needed.
#post_scan_form(scope, body) ⇒ ApiResponse

The default media type of the response is multipart-mixed.
#post_shipments_tracking(scope, body) ⇒ ApiResponse

Submits a real-time tracking event for a shipment in transit.
#post_subscriptions_adjustment(scope, body) ⇒ ApiResponse

Create a Subscription to Adjustment Events Topic.
#post_subscriptions_dispute(scope, body) ⇒ ApiResponse

Create a Subscription to Disputes Events Topic.
#post_subscriptions_ncoa(scope, body) ⇒ ApiResponse

Create a Subscription to be alerted for Change of Address for specfied the address.
#post_subscriptions_package_transaction_details(scope, body) ⇒ ApiResponse

Create a Subscription to Package Transaction Details Events Topic.
#post_subscriptions_tracking(scope, body) ⇒ ApiResponse

Create a Subscription to Tracking Events Topic.
#post_subscriptions_unpaid_subscriptions(scope, body) ⇒ ApiResponse

Create a Subscription to Unpaid Packages Events Topic.
#post_token(scope, body: nil) ⇒ ApiResponse

Issue one or more OAuth tokens for a client application to use to make subsequent resource requests.
#post_total_rates_search(scope, body: nil) ⇒ ApiResponse

This API returns a list of eligible prices, including extra service fees, given the dimensions, weight, origin and destination of your package.
#post_total_rates_search1(scope, body: nil) ⇒ ApiResponse

Performs a search for base price and extraServices using the submitted rate ingredients.
#post_tracking_number_campaigns(scope, crid, campaign_id, body) ⇒ ApiResponse

Add tracking numbers to an Informed Delivery package campaign determines the level of access and permissions for the API.
#proof_of_delivery(tracking_number, scope, body, x_forwarded_for: nil) ⇒ ApiResponse

Proof of Delivery is a letter that includes the recipient’s name and a copy of their signature.
#put_campaigns(scope, crid, campaign_id, body) ⇒ ApiResponse

Edit a previously existing Informed Delivery campaign determines the level of access and permissions for the API.
#put_carrier_pickup_confirmation_number(scope, confirmation_number, if_match, body) ⇒ ApiResponse

Update information contained in a previously scheduled carrier pickup such as the pickup date, the types and counts of packages for the carrier to pick up, the weight or the pickup location.
#put_fast_appointment(scope, body: nil) ⇒ ApiResponse

Update Appointment Request provides the ability to update an appointment.
#put_package_campaigns(scope, crid, campaign_id, body) ⇒ ApiResponse

Edit a previously existing Informed Delivery package campaign determines the level of access and permissions for the API.
#put_subscriptions_adjustment_id(scope, subscription_id, if_match, body) ⇒ ApiResponse

Use this endpoint to update the callback url, secret, or status.
#put_subscriptions_dispute_id(scope, subscription_id, if_match, body) ⇒ ApiResponse

Use this endpoint to update the callback url, secret, or status.
#put_subscriptions_ncoa_id(scope, subscription_id, if_match, body) ⇒ ApiResponse

Use this endpoint to update the callback url, secret, or status.
#put_subscriptions_package_transaction_details_id(scope, subscription_id, if_match, body) ⇒ ApiResponse

Use this endpoint to update the callback url, secret, or status.
#put_subscriptions_tracking_id(scope, subscription_id, if_match, body) ⇒ ApiResponse

Use this endpoint to update the callback url, secret, or status.
#put_subscriptions_unpaid_packages_id(scope, subscription_id, if_match, body) ⇒ ApiResponse

“Use this endpoint to update the callback URL, secret, or status.
#query_mail_campaigns(scope, crid, offset: 0, limit: 100, sort: nil, ezsearch: nil, barcode_count: nil, brand_display_name: nil, campaign_code: nil, mid: nil, mailpiece_shape: nil, campaign_title: nil, campaign_type: nil, created_datetime: nil, campaign_source: nil, end_date: nil, end_serial: nil, last_modified_datetime: nil, last_modified_source: nil, last_modified_username: nil, mail_owner_crid: nil, mail_owner_name: nil, postal_one_saturation_job_id: nil, is_shareable: nil, start_date: nil, start_serial: nil, status: nil, submitted_datetime: nil, has_url_params: nil) ⇒ ApiResponse

Search, filter, sort, and paginate campaigns for a given Submitter CRID determines the level of access and permissions for the API.

Methods inherited from BaseApi

#initialize, #new_parameter, #new_request_builder, #new_response_handler, user_agent, user_agent_parameters

Constructor Details

This class inherits a constructor from UspsApi::BaseApi

Instance Method Details

#delete_campaigns(scope, crid, campaign_id) ⇒ `ApiResponse`

Cancel a previously existing Informed Delivery campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). campaign

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
campaign_id (String) —

Required parameter: ID of Informed Delivery

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1711

def delete_campaigns(scope,
                     crid,
                     campaign_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsErrorException)
                .local_error('401',
                             'Unauthorized',
                             InformedDeliveryCampaignsErrorException)
                .local_error('403',
                             'Forbidden',
                             InformedDeliveryCampaignsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             InformedDeliveryCampaignsErrorException)
                .local_error('503',
                             'Service Unavailable',
                             InformedDeliveryCampaignsErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

#delete_carrier_pickup_confirmation_number(scope, confirmation_number, if_match) ⇒ `ApiResponse`

Cancel a previously scheduled carrier pick up. A carrier pickup can no longer be updated or cancelled once cancelled. A successful response indicates the carrier pickup has been cancelled. determines the level of access and permissions for the API. The value of this parameter should be set to “pickup” for pickup-related operations. Carrier Pickup confirmation number. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope3) —

Required parameter: The scope of the request, which
confirmation_number (String) —

Required parameter: This is the
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 745

def delete_carrier_pickup_confirmation_number(scope,
                                              confirmation_number,
                                              if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/carrier-pickup/{confirmationNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(confirmation_number, key: 'confirmationNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PickupErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PickupErrorException)
                .local_error('403',
                             'Access is denied.',
                             PickupErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PickupErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             PickupErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_containers_with_container_id(scope, container_id) ⇒ `ApiResponse`

In the context of container tracking, deleting all tracking numbers from a container results in an empty container, which allows for the addition of new tracking numbers. This process effectively clears out any previous tracking information associated with the container, allowing for a fresh start. determines the level of access and permissions for the API. The value of this parameter should be set to “containers” for containers-related operations. container

Parameters:

scope (Scope4) —

Required parameter: The scope of the request, which
container_id (String) —

Required parameter: Container id for the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 857

def delete_containers_with_container_id(scope,
                                        container_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/containers/{container-id}/packages',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(container_id, key: 'container-id')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             ContainersErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             ContainersErrorException)
                .local_error('403',
                             'Access is denied.',
                             ContainersErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             ContainersErrorException)
                .local_error('503',
                             'Service is unavailable',
                             ContainersErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_containers_with_container_id_with_packages(scope, container_id, tracking_number) ⇒ `ApiResponse`

In the context of container tracking, deleting one tracking number from a container. determines the level of access and permissions for the API. The value of this parameter should be set to “containers” for containers-related operations. container. the package.

Parameters:

scope (Scope4) —

Required parameter: The scope of the request, which
container_id (String) —

Required parameter: Container id for the
tracking_number (String) —

Required parameter: tracking number for

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 906

def delete_containers_with_container_id_with_packages(scope,
                                                      container_id,
                                                      tracking_number)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/containers/{container-id}/packages/{tracking-number}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(container_id, key: 'container-id')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'tracking-number')
                                .is_required(true)
                                .should_encode(true))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             ContainersErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             ContainersErrorException)
                .local_error('403',
                             'Access is denied.',
                             ContainersErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             ContainersErrorException)
                .local_error('503',
                             'Service is unavailable',
                             ContainersErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_fast_appointment(scope, body: nil) ⇒ `ApiResponse`

Cancel Appointment Request provides the ability to cancel an appointment. determines the level of access and permissions for the API. The value of this parameter should be set to “fast-appointments” for fast-appointments-related operations. corresponding to the supported grant types.

Parameters:

scope (Scope2) —

Required parameter: The scope of the request, which
body (CancellationRequest) (defaults to: nil) —

Optional parameter: The input parameters

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 395

def delete_fast_appointment(scope,
                            body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/fast-appointments/appointment',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CancellationResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             FastAppointmentsErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             FastAppointmentsErrorException)
                .local_error('403',
                             'Access is denied.',
                             FastAppointmentsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             FastAppointmentsErrorException)
                .local_error('503',
                             'Service is unavailable',
                             FastAppointmentsErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_indicia_imb(scope, imb, x_payment_authorization_token) ⇒ `ApiResponse`

Cancel an Intelligent Mail Barcode (IMB) label for First-Class letters, flats, and cards or submit a refund request by providing the IMB. An IMB can be canceled if it has not yet been manifested. If it has been manifested, a refund request will be submitted for the unused IMB. Indicia without an IMB cannot be canceled. Note:

You can only request a refund of an IMB once.

determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. for First-Class letters, flats, and cards. Authorization Token from the payments API Call.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
imb (String) —

Required parameter: The Intelligent Mail Barcode (IMB)
x_payment_authorization_token (String) —

Required parameter: Payment

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3489

def delete_indicia_imb(scope,
                       imb,
                       x_payment_authorization_token)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/indicia/imb/{imb}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(imb, key: 'imb')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CancelIntelligentMailBarcodeResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_international_label(scope, tracking_number, x_payment_authorization_token) ⇒ `ApiResponse`

Cancel a label or submit a refund request by providing the label’s tracking number. A label can be canceled if a Shipping Services File has not been created. If a Shipping Services File has been created, submit a refund request for an unused label. A label is eligible for a refund if:

If the label has had a Shipping Services File created for it
The label is not from Click-N-Ship or PC Postage
Is a SCAN Form label that has had its Shipping Services File created

Note:

If the label is canceled, a Shipping Services File will not be created.
If a refund request is successfully submitted, a disputeId will be

returned that can be used to then track the status of the refund request. The system will only give one unique disputeId per customer reference ID (CRID) per day. Duplicate submissions of the same label, for the same CRID, on the same day, will be rejected. determines the level of access and permissions for the API. The value of this parameter should be set to “international-labels” for international-labels-related operations. number of the label. Authorization Token from the payments API Call.

Parameters:

scope (Scope8) —

Required parameter: The scope of the request, which
tracking_number (String) —

Required parameter: The unique tracking
x_payment_authorization_token (String) —

Required parameter: Payment

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2554

def delete_international_label(scope,
                               tracking_number,
                               x_payment_authorization_token)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/international-label/{trackingNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalLabelsCancelLabelResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_label(scope, tracking_number, x_payment_authorization_token) ⇒ `ApiResponse`

If the label has had a Shipping Services File created for it
The label is not from Click-N-Ship or PC Postage
Is a SCAN Form label that has had its Shipping Services File created

Note:

If the label is canceled, a Shipping Services File will not be created.
If a refund request is successfully submitted, a disputeId will be

returned that can be used to then track the status of the refund request. The system will only give one unique disputeId per customer reference ID (CRID) per day. Duplicate submissions of the same label, for the same CRID, on the same day, will be rejected. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. the domestic label. Authorization Token from the payments API Call.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
tracking_number (String) —

Required parameter: The tracking number of
x_payment_authorization_token (String) —

Required parameter: Payment

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3241

def delete_label(scope,
                 tracking_number,
                 x_payment_authorization_token)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/label/{trackingNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelsCancelLabelResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ `ApiResponse`

Delete a label branding image associated with your customer reference ID (CRID). The CRID will be taken from the ‘LABEL_OWNER` role of your Payment Authorization token. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. branding image Authorization Token from the payments API Call.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
image_uuid (String) —

Required parameter: The UUID of a label
x_payment_authorization_token (String) —

Required parameter: Payment

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3736

def delete_label_branding(scope,
                          image_uuid,
                          x_payment_authorization_token)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/branding/{imageUUID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(image_uuid, key: 'imageUUID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelBrandingImageDeleteResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_package_campaigns(scope, crid, campaign_id) ⇒ `ApiResponse`

Cancel a previously existing Informed Delivery package campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-package-campaigns” for informed-delivery-package-campaigns-related operations. Customer Registration ID (CRID). campaign.

Parameters:

scope (Scope7) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The Package campaign submitter’s
campaign_id (String) —

Required parameter: Unique identifier for the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2292

def delete_package_campaigns(scope,
                             crid,
                             campaign_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CancelPackageCampaignResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryPackageCampaignsErrorException))
    .execute
end

#delete_subscriptions_adjustment_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

Use this endpoint to delete a Subscription by its unique identifier. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-adjustments” for subscriptions-adjustments-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope28) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6175

def delete_subscriptions_adjustment_id(scope,
                                       subscription_id,
                                       if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_subscriptions_dispute_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

Use this endpoint to delete a Subscription by its unique identifier. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-disputes” for subscriptions-disputes-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope29) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6446

def delete_subscriptions_dispute_id(scope,
                                    subscription_id,
                                    if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_subscriptions_ncoa_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

Use this endpoint to delete a Subscription by its unique identifier. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-ncoa” for subscriptions-ncoa-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope30) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6715

def delete_subscriptions_ncoa_id(scope,
                                 subscription_id,
                                 if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_subscriptions_package_transaction_details_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

Use this endpoint to delete a Subscription by its unique identifier. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-package-transaction-details” for subscriptions-package-transaction-details-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope31) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6993

def delete_subscriptions_package_transaction_details_id(scope,
                                                        subscription_id,
                                                        if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_subscriptions_tracking_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

Use this endpoint to delete a Subscription by its unique identifier. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-tracking” for subscriptions-tracking-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope32) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7268

def delete_subscriptions_tracking_id(scope,
                                     subscription_id,
                                     if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#delete_subscriptions_unpaid_packages_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

Use this endpoint to delete a Subscription by its unique identifier. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-unpaid-packages” for subscriptions-unpaid-packages-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation.

Parameters:

scope (Scope33) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7540

def delete_subscriptions_unpaid_packages_id(scope,
                                            subscription_id,
                                            if_match)
  @api_call
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in  a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_address(scope, street_address, state, firm: nil, secondary_address: nil, city: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ `ApiResponse`

Standardizes street addresses including city and street abbreviations as well as providing missing information such as ZIP Code™ and ZIP + 4®. Must specify a street address, a state, and either a city or a ZIP Code™. determines the level of access and permissions for the API. The value of this parameter should be set to “addresses” for addresses-related operations. building along with the name of the road or street on which it is located. the address. the address. designator, such as apartment(APT) or suite(STE) number, defining the exact location of the address within a building. For more information please see [Postal Explorer](pe.usps.com/text/pub28/28c2_003.htm). address. code relevant only for Puerto Rico addresses. code. component of the ZIP+4 code. Using the correct ZIP+4 reduces the number of times your mail is handled and can decrease the chance of a misdelivery or error.

Parameters:

scope (Scope) —

Required parameter: The scope of the request, which
street_address (String) —

Required parameter: The number of a
state (String) —

Required parameter: The two-character state code of
firm (String) (defaults to: nil) —

Optional parameter: Firm/business corresponding to
secondary_address (String) (defaults to: nil) —

Optional parameter: The secondary unit
city (String) (defaults to: nil) —

Optional parameter: This is the city name of the
urbanization (String) (defaults to: nil) —

Optional parameter: This is the urbanization
zip_code (String) (defaults to: nil) —

Optional parameter: This is the 5-digit ZIP
zip_plus4 (String) (defaults to: nil) —

Optional parameter: This is the 4-digit

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 41

def get_address(scope,
                street_address,
                state,
                firm: nil,
                secondary_address: nil,
                city: nil,
                urbanization: nil,
                zip_code: nil,
                zip_plus4: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/address',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(street_address, key: 'streetAddress')
                             .is_required(true))
               .query_param(new_parameter(state, key: 'state')
                             .is_required(true))
               .query_param(new_parameter(firm, key: 'firm'))
               .query_param(new_parameter(secondary_address, key: 'secondaryAddress'))
               .query_param(new_parameter(city, key: 'city'))
               .query_param(new_parameter(urbanization, key: 'urbanization'))
               .query_param(new_parameter(zip_code, key: 'ZIPCode'))
               .query_param(new_parameter(zip_plus4, key: 'ZIPPlus4'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(AddressesAddressResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Address Not Found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_addresses(scope, street_address, firm_name: nil, secondary_address: nil, city: nil, state: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ `ApiResponse`

Standardizes street addresses including city and street abbreviations as well as providing missing information such as ZIP Code™ and ZIP + 4®. Must specify a street address, a state, and either a city or a ZIP Code™. determines the level of access and permissions for the API. The value of this parameter should be set to “addresses” for addresses-related operations. building along with the name of the road or street on which it is located. to the address. designator, such as apartment(APT) or suite(STE) number, defining the exact location of the address within a building. For more information please see [Postal Explorer](pe.usps.com/text/pub28/28c2_003.htm). address. the address. code relevant only for Puerto Rico addresses. code. component of the ZIP + 4® code. Using the correct ZIP + 4® reduces the number of times your mail is handled and can decrease the chance of a misdelivery or error.

Parameters:

scope (Scope) —

Required parameter: The scope of the request, which
street_address (String) —

Required parameter: The number of a
firm_name (String) (defaults to: nil) —

Optional parameter: Firm/business corresponding
secondary_address (String) (defaults to: nil) —

Optional parameter: The secondary unit
city (String) (defaults to: nil) —

Optional parameter: This is the city name of the
state (String) (defaults to: nil) —

Optional parameter: The two-character state code of
urbanization (String) (defaults to: nil) —

Optional parameter: This is the urbanization
zip_code (String) (defaults to: nil) —

Optional parameter: This is the 5-digit ZIP
zip_plus4 (String) (defaults to: nil) —

Optional parameter: This is the 4-digit

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1339

def get_addresses(scope,
                  street_address,
                  firm_name: nil,
                  secondary_address: nil,
                  city: nil,
                  state: nil,
                  urbanization: nil,
                  zip_code: nil,
                  zip_plus4: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/address',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(street_address, key: 'streetAddress')
                             .is_required(true))
               .query_param(new_parameter(firm_name, key: 'firmName'))
               .query_param(new_parameter(secondary_address, key: 'secondaryAddress'))
               .query_param(new_parameter(city, key: 'city'))
               .query_param(new_parameter(state, key: 'state'))
               .query_param(new_parameter(urbanization, key: 'urbanization'))
               .query_param(new_parameter(zip_code, key: 'ZIPCode'))
               .query_param(new_parameter(zip_plus4, key: 'ZIPPlus4'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(AddressesAddressResponse1.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Address Not Found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_adjustments(scope, crid, tracking_number, event_type, destination_zip_code: nil) ⇒ `ApiResponse`

The Adjustments API enables users to receive USPS Ship adjustments by a Package Identification Code (PIC) aka Tracking Number. determines the level of access and permissions for the API. The value of this parameter should be set to “adjustments” for adjustments-related operations. representation of package barcode data, commonly known as its tracking number. the adjustment. ZIP Code™.

Parameters:

scope (Scope1) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: Filter by CRID.
tracking_number (String) —

Required parameter: The human-readable
event_type (EventType) —

Required parameter: The type of event for
destination_zip_code (String) (defaults to: nil) —

Optional parameter: The destination

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 240

def get_adjustments(scope,
                    crid,
                    tracking_number,
                    event_type,
                    destination_zip_code: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/adjustments/{CRID}/{trackingNumber}/{eventType}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(event_type, key: 'eventType')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(destination_zip_code, key: 'destinationZIPCode'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(AdjustmentsAdjustmentDetails.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_appointment_availability(scope, body: nil) ⇒ `ApiResponse`

Allows customers to check for appointment slots at the requested facility. determines the level of access and permissions for the API. The value of this parameter should be set to “fast-appointments” for fast-appointments-related operations. corresponding to the supported grant types.

Parameters:

scope (Scope2) —

Required parameter: The scope of the request, which
body (SlotAvailability) (defaults to: nil) —

Optional parameter: The input parameters

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 443

def get_appointment_availability(scope,
                                 body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/appointment-availability',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Slots.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             FastAppointmentsErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             FastAppointmentsErrorException)
                .local_error('403',
                             'Access is denied.',
                             FastAppointmentsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             FastAppointmentsErrorException)
                .local_error('503',
                             'Service is unavailable',
                             FastAppointmentsErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_campaigns(scope, crid, campaign_id) ⇒ `ApiResponse`

Return a single Informed Delivery campaign for a given Submitter CRID and Campaign ID determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). campaign

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
campaign_id (String) —

Required parameter: ID of Informed Delivery

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1657

def get_campaigns(scope,
                  crid,
                  campaign_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Campaign.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsErrorException)
                .local_error('401',
                             'Unauthorized',
                             InformedDeliveryCampaignsErrorException)
                .local_error('403',
                             'Forbidden',
                             InformedDeliveryCampaignsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             InformedDeliveryCampaignsErrorException)
                .local_error('503',
                             'Service Unavailable',
                             InformedDeliveryCampaignsErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

#get_campaigns1(scope, crid, offset: 0, limit: 100, sort: nil, ezsearch: nil, barcode_count: nil, brand_display_name: nil, campaign_code: nil, campaign_grouping_code: nil, mid: nil, campaign_title: nil, created_datetime: nil, end_date: nil, last_modified_datetime: nil, mail_owner_crid: nil, mail_owner_name: nil, start_date: nil, status: nil, submitted_datetime: nil) ⇒ `ApiResponse`

Search, filter, sort, and paginate package campaigns for a given Submitter CRID determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-package-campaigns” for informed-delivery-package-campaigns-related operations. Registration ID (CRID). before returning results. This field must be either be 0 or be a multiple of the limit variable (e.g., is limit is 10, offset can be 0, 10, 20, etc.). If no offset parameter is included at all, a default of 0 will be used. This field must be a number between 1 and 1000. If no limit parameter is included at all, a default of 100 will be used. this, an integrator can input any column that they would like to sort by (e.g., sort=brandDisplayName,desc). An integrator can indicate either an ascending or descending order by inputting asc or desc after the field name. If asc or desc is not included, then the field will be sorted ascending by default. If no sort parameter is included at all, the response will be sorted by lastModifiedDatetime,desc by default. “contains” search across the Campaign Grouping Code, Campaign Code, Brand Display Name, and Campaign Title fields. For example inputting “Sale” will return any campaign for the CRID with a Campaign Grouping Code, Campaign Title, Campaign Code, or Brand Display Name that contains the word “Sale”. associated with a campaign. that is placed on Informed Delivery’s UIs when campaign is displayed. describes the campaign being created. This field is put into the campaign reports created for the campaign. field that describes the campaign being created. This field is put into the campaign reports created for the campaign. campaign. describes the campaign being created. This field is put into the campaign reports created for the campaign. campaign creation. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “createdDatetime>2025-07-05”). displayed update made to campaign, inclusive of status changes that occur when a campaign activates or completes. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “lastModifiedDatetime>2025-07-05”). ID (CRID) of the Mail Owner associated with the Informed Delivery campaign. associated with the Informed Delivery campaign. displayed values include Submitted, Active, Complete, Inactive, Cancelled, and Deleted campaign submission. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “submittedDatetime>2025-07-05”).

Parameters:

scope (Scope7) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
offset (Integer) (defaults to: 0) —

Optional parameter: Number of records to skip
limit (Integer) (defaults to: 100) —

Optional parameter: Number of results per page.
sort (String) (defaults to: nil) —

Optional parameter: Sorting order for results. To use
ezsearch (String) (defaults to: nil) —

Optional parameter: This filter will do a
barcode_count (Float) (defaults to: nil) —

Optional parameter: Number of packages
brand_display_name (String) (defaults to: nil) —

Optional parameter: User defined field
campaign_code (String) (defaults to: nil) —

Optional parameter: User defined field that
campaign_grouping_code (String) (defaults to: nil) —

Optional parameter: User defined
mid (String) (defaults to: nil) —

Optional parameter: The Mailer ID associated with the
campaign_title (String) (defaults to: nil) —

Optional parameter: User defined field that
created_datetime (Date) (defaults to: nil) —

Optional parameter: Date of initial
end_date (Date) (defaults to: nil) —

Optional parameter: Last day campaign will be
last_modified_datetime (Date) (defaults to: nil) —

Optional parameter: Date of last
mail_owner_crid (String) (defaults to: nil) —

Optional parameter: Customer Registration
mail_owner_name (String) (defaults to: nil) —

Optional parameter: Name of the Mail Owner
start_date (Date) (defaults to: nil) —

Optional parameter: First day campaign will be
status (Status1) (defaults to: nil) —

Optional parameter: Status of campaign - possible
submitted_datetime (Date) (defaults to: nil) —

Optional parameter: Date of initial

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2138

def get_campaigns1(scope,
                   crid,
                   offset: 0,
                   limit: 100,
                   sort: nil,
                   ezsearch: nil,
                   barcode_count: nil,
                   brand_display_name: nil,
                   campaign_code: nil,
                   campaign_grouping_code: nil,
                   mid: nil,
                   campaign_title: nil,
                   created_datetime: nil,
                   end_date: nil,
                   last_modified_datetime: nil,
                   mail_owner_crid: nil,
                   mail_owner_name: nil,
                   start_date: nil,
                   status: nil,
                   submitted_datetime: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .query_param(new_parameter(sort, key: 'sort'))
               .query_param(new_parameter(ezsearch, key: 'ezsearch'))
               .query_param(new_parameter(barcode_count, key: 'barcodeCount'))
               .query_param(new_parameter(brand_display_name, key: 'brandDisplayName'))
               .query_param(new_parameter(campaign_code, key: 'campaignCode'))
               .query_param(new_parameter(campaign_grouping_code, key: 'campaignGroupingCode'))
               .query_param(new_parameter(mid, key: 'MID'))
               .query_param(new_parameter(campaign_title, key: 'campaignTitle'))
               .query_param(new_parameter(created_datetime, key: 'createdDatetime'))
               .query_param(new_parameter(end_date, key: 'endDate'))
               .query_param(new_parameter(last_modified_datetime, key: 'lastModifiedDatetime'))
               .query_param(new_parameter(mail_owner_crid, key: 'mailOwnerCRID'))
               .query_param(new_parameter(mail_owner_name, key: 'mailOwnerName'))
               .query_param(new_parameter(start_date, key: 'startDate'))
               .query_param(new_parameter(status, key: 'status'))
               .query_param(new_parameter(submitted_datetime, key: 'submittedDatetime'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CampaignDetailsResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryPackageCampaignsQueryErrorResponseException))
    .execute
end

#get_campaigns_callback(scope, crid, offset: 0, limit: 100, sort: nil, campaign_id: nil, submitted_datetime: nil, total_barcodes: nil, total_barcodes_added: nil, total_barcodes_failed: nil) ⇒ `ApiResponse`

Search all callback keys for Add Many IMB transactions performed by given Submitter CRID determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). before returning results. This field must be either be 0 or be a multiple of the limit variable (e.g., is limit is 10, offset can be 0, 10, 20, etc.). If no offset parameter is included at all, a default of 0 will be used. This field must be a number between 1 and 1000. If no limit parameter is included at all, a default of 100 will be used. this, an integrator can input any column that they would like to sort by (e.g., sort=submittedDatetime,desc). An integrator can indicate either an ascending or descending order by inputting asc or desc after the field name. If asc or desc is not included, then the field will be sorted ascending by default. If no sort parameter is included at all, the response will be sorted by submittedDatetime,desc by default. Delivery campaign associated with the callback key transaction. callback key transaction. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “submittedDatetime>2025-07-05”). barcodes in a single callback key transaction. of barcodes successfully added to the campaign via the callback key transaction. of barcodes that failed to be added to the campaign via the callback key transaction.

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
offset (Integer) (defaults to: 0) —

Optional parameter: Number of records to skip
limit (Integer) (defaults to: 100) —

Optional parameter: Number of results per page.
sort (String) (defaults to: nil) —

Optional parameter: Sorting order for results. To use
campaign_id (String) (defaults to: nil) —

Optional parameter: ID of the Informed
submitted_datetime (Date) (defaults to: nil) —

Optional parameter: Date of initial
total_barcodes (Float) (defaults to: nil) —

Optional parameter: The total number of
total_barcodes_added (Float) (defaults to: nil) —

Optional parameter: The total number
total_barcodes_failed (Float) (defaults to: nil) —

Optional parameter: The total number

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1882

def get_campaigns_callback(scope,
                           crid,
                           offset: 0,
                           limit: 100,
                           sort: nil,
                           campaign_id: nil,
                           submitted_datetime: nil,
                           total_barcodes: nil,
                           total_barcodes_added: nil,
                           total_barcodes_failed: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}/callback',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .query_param(new_parameter(sort, key: 'sort'))
               .query_param(new_parameter(campaign_id, key: 'campaignID'))
               .query_param(new_parameter(submitted_datetime, key: 'submittedDatetime'))
               .query_param(new_parameter(total_barcodes, key: 'totalBarcodes'))
               .query_param(new_parameter(total_barcodes_added, key: 'totalBarcodesAdded'))
               .query_param(new_parameter(total_barcodes_failed, key: 'totalBarcodesFailed'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3CampaignsCallbackResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

#get_carrier_pickup_confirmation_number(scope, confirmation_number) ⇒ `ApiResponse`

Get the previously scheduled carrier pickup by confirmation number. Responds with the entity tag (ETag) to use when updating or cancelling this pickup. determines the level of access and permissions for the API. The value of this parameter should be set to “pickup” for pickup-related operations. Carrier Pickup confirmation number.

Parameters:

scope (Scope3) —

Required parameter: The scope of the request, which
confirmation_number (String) —

Required parameter: This is the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 626

def get_carrier_pickup_confirmation_number(scope,
                                           confirmation_number)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/carrier-pickup/{confirmationNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(confirmation_number, key: 'confirmationNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PickupConfirmation.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PickupErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PickupErrorException)
                .local_error('403',
                             'Access is denied.',
                             PickupErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PickupErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             PickupErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_carrier_pickup_eligibility(scope, street_address, secondary_address: nil, city: nil, state: nil, zip_code: nil, zip_plus4: nil, urbanization: nil) ⇒ `ApiResponse`

Check carrier pickup service availability at the specified address. Either the city and state or the ZIP Code™ is required, in addition to the street address. Successful responses include the USPS standardized address when this location is eligible for carrier pickup. determines the level of access and permissions for the API. The value of this parameter should be set to “pickup” for pickup-related operations. building along with the name of the road or street on which it is located. designator, such as apartment(APT) or suite(STE) number, defining the exact location of the address within a building. For more information please see [Postal Explorer](pe.usps.com/text/pub28/28c2_003.htm). address. two-character state code of the address. The request accepts either the full state name or a two-character state code. The response will always return the two-character state code. code. component of the ZIP+4 code. Using the correct Zip+4 reduces the number of times your mail is handled and can decrease the chance of a misdelivery or error. code relevant only for Puerto Rico addresses.

Parameters:

scope (Scope3) —

Required parameter: The scope of the request, which
street_address (String) —

Required parameter: The number of a
secondary_address (String) (defaults to: nil) —

Optional parameter: The secondary unit
city (String) (defaults to: nil) —

Optional parameter: This is the city name of the
state (String) (defaults to: nil) —

Optional parameter: This is the state name or
zip_code (String) (defaults to: nil) —

Optional parameter: This is the 5-digit ZIP
zip_plus4 (String) (defaults to: nil) —

Optional parameter: This is the 4-digit
urbanization (String) (defaults to: nil) —

Optional parameter: This is the urbanization

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 514

def get_carrier_pickup_eligibility(scope,
                                   street_address,
                                   secondary_address: nil,
                                   city: nil,
                                   state: nil,
                                   zip_code: nil,
                                   zip_plus4: nil,
                                   urbanization: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/carrier-pickup/eligibility',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(street_address, key: 'streetAddress')
                             .is_required(true))
               .query_param(new_parameter(secondary_address, key: 'secondaryAddress'))
               .query_param(new_parameter(city, key: 'city'))
               .query_param(new_parameter(state, key: 'state'))
               .query_param(new_parameter(zip_code, key: 'ZIPCode'))
               .query_param(new_parameter(zip_plus4, key: 'ZIPPlus4'))
               .query_param(new_parameter(urbanization, key: 'urbanization'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PickupAddress.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PickupErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PickupErrorException)
                .local_error('403',
                             'Access is denied.',
                             PickupErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PickupErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             PickupErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_city_state(scope, zip_code) ⇒ `ApiResponse`

Returns the city and state corresponding to the given ZIP Code™. determines the level of access and permissions for the API. The value of this parameter should be set to “addresses” for addresses-related operations. code.

Parameters:

scope (Scope) —

Required parameter: The scope of the request, which
zip_code (String) —

Required parameter: This is the 5-digit ZIP

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 106

def get_city_state(scope,
                   zip_code)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/city-state',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(zip_code, key: 'ZIPCode')
                             .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(AddressesCityAndState.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'A bad request was received.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_coa_records_search(scope, body) ⇒ `ApiResponse`

Returns a list of records for a person’s current and old addresses. determines the level of access and permissions for the API. The value of this parameter should be set to “ncoa-data-services” for ncoa-data-services-related operations. description here

Parameters:

scope (Scope15) —

Required parameter: The scope of the request, which
body (ChangeOfAddressSearchRequest) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4411

def get_coa_records_search(scope,
                           body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(RecordsResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Missing required fields in the request will result in a 400'\
                              ' response.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized or invalid token is received in the request.',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden response means this client doesn’t have the proper'\
                              ' scope/role',
                             AddressesErrorException)
                .local_error('404',
                             'Indicates the endpoint was not found.',
                             AddressesErrorException)
                .local_error('500',
                             'An error has occurred within the application.',
                             AddressesErrorException))
    .execute
end

#get_code(scope_template, response_type, client_id, redirect_uri, user_id, scope: nil, state: nil) ⇒ `ApiResponse`

The client application identifier and redirect URI are configured during client application registration. The client application redirect URI specified here must match the one specified during client registration. The Authorization Code request and response is the first leg of the three-legged Authorization Code flow stipulated here:

**Authorization Code Grant**, see [IETF 6749, section

4.1](datatracker.ietf.org/doc/html/rfc6749#section-4.1).

The authorization code and state are appended as query parameters to the

redirect_uri upon a _successful___ authorization code redirection response.

Example
 ```

mycompany.com/authorize?code=lcJNTxcLB&state=IntcInJlZGlyZWN0X3RvX CI6XCIvZGFzaGJvYXJkXCIsXCJ1c2VyX2lkXCI6XCJhYmMtMTIzXCJ9Ig==

```

Errors are appended as query parameters to the redirect_uri once the

client application credentials are authenticated, and both the client_id and the redirect_uri are validated. An _error___ redirection response is then sent. The application is authorized to make the request, but other fields in the request are causing an error to occur.

Example
```

mycompany.com/authorize?error=access_denied&error_description=The% 20resource%20owner%20authorization%20grant%20does%20not%20exist%20or%20has %20been%20revoked.&error_uri=https%3A%2F%2Fdatatracker.ietf.org%2Fdoc%2Fht ml%2Frfc6749%23section-4.1.2.1&state=IntcInJlZGlyZWN0X3RvXCI6XCIvZGFzaGJvY XJkXCIsXCJ1c2VyX2lkXCI6XCJhYmMtMTIzXCJ9Ig==

```

**Authorization codes have a short expiration time. The client

application must complete the authorization code flow by requesting OAuth tokens using the authorization code.** request, which determines the level of access and permissions for the API. The value of this parameter should be set to “oauth2” for oauth2-related operations. response being requested, ‘code’ in this case. client application making the request. Resource Identifier (URI) that has been previously registered for the third-party client application. This input must be an exact match with the one(s) previously registered. The URI must use a encrypted connection, preventing attackers from intercepting and reading autorization code responses. The redirect_uri must use the https:// scheme for security reasons. See [Best Current Practice for OAuth 2.0 Security](datatracker.ietf.org/doc/html/rfc9700#name-client-as-ope n-redirector) for further security awareness. of the user’s account. requested. A client application may request a subset of scope that has already been configured during client application registration. The scope registered for the client application is used as default when the scope is omitted. **Only specify the scope in the request when the client application requires less scope, i.e. less access to APIs, than the default.** authorization code request is returned in authorization code response. It is recommended that the value for the state is a Base64 encoded, stringified JSON object and its value should be sufficient to correlate the code response to an authorization code request and user. A nonce value should be included in this JSON object for additional security. Effectively using the state parameter mitigates Cross-Site Request Forgery (CSRF). See [Best Current Practice for OAuth 2.0 Security](datatracker.ietf.org/doc/html/rfc9700#name-nonce) for further security awareness. The following is a normative example: “‘ {

"redirect_to": "/dashboard",   "user_id": "abcd1234",   "nonce":

“553393870385” } “‘ The result of converting to a string and Base64 encoding is: “` IntcInJlZGlyZWN0X3RvXCI6IFwiL2Rhc2hib2FyZFwiLFwidXNlcl9pZFwiOiBcImFiY2QxMj M0XCIsXCJub25jZVwiOiBcIjU1MzM5Mzg3MDM4NVwifSI= “`

Parameters:

scope_template (Scope16) —

Required parameter: The scope of the
response_type (ResponseType) —

Required parameter: The type of
client_id (String) —

Required parameter: The unique identifier of the
redirect_uri (String) —

Required parameter: The redirection Uniform
user_id (String) —

Required parameter: The unique subject identifier
scope (String) (defaults to: nil) —

Optional parameter: The OAuth2 scope being
state (String) (defaults to: nil) —

Optional parameter: The state value passed in the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4650

def get_code(scope_template,
             response_type,
             client_id,
             redirect_uri,
             user_id,
             scope: nil,
             state: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/authorize',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope_template, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(response_type, key: 'response_type')
                             .is_required(true))
               .query_param(new_parameter(client_id, key: 'client_id')
                             .is_required(true))
               .query_param(new_parameter(redirect_uri, key: 'redirect_uri')
                             .is_required(true))
               .query_param(new_parameter(user_id, key: 'user_id')
                             .is_required(true))
               .query_param(new_parameter(scope, key: 'scope'))
               .query_param(new_parameter(state, key: 'state'))
               .auth(Single.new('BearerTokenAuth')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  Check the input parameters and values.',
                             OauthStandardErrorResponseException)
                .local_error('401',
                             'Unauthorized Request.  Check the authentication scheme and'\
                              ' values being used to make the request.',
                             OauthStandardErrorResponseException)
                .local_error('403',
                             'Forbidden Request.  The request parameters conflict with'\
                              ' application registration. Suspected Potential Intrusion.',
                             OauthStandardErrorResponseException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             OauthStandardErrorResponseException)
                .local_error('503',
                             'Service Unavailable.',
                             OauthStandardErrorResponseException))
    .execute
end

#get_detail_data(scope, crid, callback_key, offset: 0, limit: 10, sort: nil, error_message: nil) ⇒ `ApiResponse`

Return IMB-level errors for a single callback key transaction determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). associated with the campaign. before returning results. This field must be either be 0 or be a multiple of the limit variable (e.g., is limit is 10, offset can be 0, 10, 20, etc.). If no offset parameter is included at all, a default of 0 will be used. This field must be a number between 1 and 1000. If no limit parameter is included at all, a default of 10 will be used. this, an integrator can input any column that they would like to sort by (e.g., sort=errorMessage,desc). An integrator can indicate either an ascending or descending order by inputting asc or desc after the field name. If asc or desc is not included, then the field will be sorted ascending by default. If no sort parameter is included at all, the response will be sorted by errorMessage,asc by default. IMB-level error message.

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
callback_key (String) —

Required parameter: The callback key
offset (Integer) (defaults to: 0) —

Optional parameter: Number of records to skip
limit (Integer) (defaults to: 10) —

Optional parameter: Number of results per page.
sort (String) (defaults to: nil) —

Optional parameter: Sorting order for results. To use
error_message (String) (defaults to: nil) —

Optional parameter: Filter results by

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1990

def get_detail_data(scope,
                    crid,
                    callback_key,
                    offset: 0,
                    limit: 10,
                    sort: nil,
                    error_message: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}/{callbackKey}/detail',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(callback_key, key: 'callbackKey')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .query_param(new_parameter(sort, key: 'sort'))
               .query_param(new_parameter(error_message, key: 'errorMessage'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(DetailSuccessResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsQueryErrorResponseException))
    .execute
end

#get_dropoff_location(scope, destination_zip_code, destination_zip_plus4: nil, mail_class: nil, processing_category: nil, destination_entry_facility_type: nil, palletized: nil, mailing_date: nil) ⇒ `ApiResponse`

The Drop Off Location API can be used to find convenient USPS® entry facilities for destination entry volume. If you supply a valid 5-digit destination ZIP Code™ and optional parameters you will be provided with one or more acceptable entry locations which can be utilized to prevent mis-shipped adjustments. This API can be used in lieu of the Parcel, Address, and Mail Direction Files currently available through FAST. determines the level of access and permissions for the API. The value of this parameter should be set to “locations” for locations-related operations. ZIP Code™ of the package. 4-digit component of the ZIP+4 code. Using the correct Zip+4 reduces the number of times your mail is handled and can decrease the chance of a misdelivery or error. package being shipped: example: PARCEL_SELECT shape of the package being shipped, for more information on package shapes see the [Physical Standards for Parcels](pe.usps.com/text/dmm300/201.htm#ep1097220). Note: - ‘IRREGULAR` is deprecated as of 2/1/2025 and will convert to `NONSTANDARD`. - `NON_MACHINABLE` is deprecated as of 2/1/2025 and will convert to `NONSTANDARD`. Optional parameter: Indicates the facility type at which the packages will be dropped off. shipment or part of the shipment is being received on a pallet. be mailed. Defaults to today when omitted. The mailing date may be today plus 0 to 7 days in advance. Enter the date in the full-date notation as defined by [RFC 3339, section 5.6](datatracker.ietf.org/doc/html/rfc3339#section-5.6).

Parameters:

scope (Scope12) —

Required parameter: The scope of the request, which
destination_zip_code (String) —

Required parameter: The destination
destination_zip_plus4 (String) (defaults to: nil) —

Optional parameter: This is the
mail_class (MailClass12) (defaults to: nil) —

Optional parameter: The mail class of the
processing_category (ProcessingCategory12) (defaults to: nil) —

Optional parameter: The
destination_entry_facility_type (DestinationEntryFacilityType) (defaults to: nil)
palletized (Palletized1) (defaults to: nil) —

Optional parameter: Indicates if the
mailing_date (Date) (defaults to: nil) —

Optional parameter: The date the package will

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3949

def get_dropoff_location(scope,
                         destination_zip_code,
                         destination_zip_plus4: nil,
                         mail_class: nil,
                         processing_category: nil,
                         destination_entry_facility_type: nil,
                         palletized: nil,
                         mailing_date: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/dropoff-locations',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(destination_zip_code, key: 'destinationZIPCode')
                             .is_required(true))
               .query_param(new_parameter(destination_zip_plus4, key: 'destinationZIPPlus4'))
               .query_param(new_parameter(mail_class, key: 'mailClass'))
               .query_param(new_parameter(processing_category, key: 'processingCategory'))
               .query_param(new_parameter(destination_entry_facility_type, key: 'destinationEntryFacilityType'))
               .query_param(new_parameter(palletized, key: 'palletized'))
               .query_param(new_parameter(mailing_date, key: 'mailingDate'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ParcelDropShipmentFacilityLocation.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Invalid Address Information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#get_enrollment(scope, body: nil) ⇒ `ApiResponse`

Allows customers to get the USPS Ship enrollment status of a MID. The API will respond with whether the MID is enrolled in USPS Ship for Outbound, Returns, both, or neither, and the enrollment start date. determines the level of access and permissions for the API. The value of this parameter should be set to “ship-enrollment” for ship-enrollment-related operations. here

Parameters:

scope (Scope26) —

Required parameter: The scope of the request, which
body (EnrollmentRequest) (defaults to: nil) —

Optional parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5822

def get_enrollment(scope,
                   body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/enrollment',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(EnrollmentStatuses.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('404',
                             'Not Found',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

#get_international_base_rates_search(scope, body: nil) ⇒ `ApiResponse`

Given a set of SSF or scan-based rate ingredients, returns a international rates. Include contract-based rates in the results when the contractId and productId are present. determines the level of access and permissions for the API. The value of this parameter should be set to “international-prices” for international-prices-related operations. parameters to be used for the query.

Parameters:

scope (Scope9) —

Required parameter: The scope of the request, which
body (InternationalBaseRatesQuery) (defaults to: nil) —

Optional parameter: The search

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2677

def get_international_base_rates_search(scope,
                                        body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/base-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalPricesBaseRatesQueryResult.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_international_extra_service_rates_search(scope, body: nil) ⇒ `ApiResponse`

Given a set of rate ingredients, returns international extra service rates. If contractId and productId are present, include contract-based rates in the results. determines the level of access and permissions for the API. The value of this parameter should be set to “international-prices” for international-prices-related operations. search parameters to be used for the query.

Parameters:

scope (Scope9) —

Required parameter: The scope of the request, which
body (InternationalExtraServiceRateQuery) (defaults to: nil) —

Optional parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2731

def get_international_extra_service_rates_search(scope,
                                                 body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/extra-service-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalExtraRateDetails.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_international_service_standard(scope, country_code, mail_class) ⇒ `ApiResponse`

Retrieve the service standard message based on the provided country code and mail class. determines the level of access and permissions for the API. The value of this parameter should be set to “international-service-standard” for international-service-standard-related operations. code. The international mail class can be one of ‘FIRST-CLASS_PACKAGE_INTERNATIONAL_SERVICE`, `PRIORITY_MAIL_INTERNATIONAL`, and `PRIORITY_MAIL_EXPRESS_INTERNATIONAL`.

Parameters:

scope (Scope10) —

Required parameter: The scope of the request, which
country_code (String) —

Required parameter: The ISO 2-char country
mail_class (InternationalMailClassOfTheLabel) —

Required parameter:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2949

def get_international_service_standard(scope,
                                       country_code,
                                       mail_class)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/international-service-standard',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(country_code, key: 'countryCode')
                             .is_required(true))
               .query_param(new_parameter(mail_class, key: 'mailClass')
                             .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3InternationalServiceStandardResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource not found.',
                             AddressesErrorException)
                .local_error('500',
                             'Internal server error.',
                             AddressesErrorException))
    .execute
end

#get_list_label_branding(scope, x_payment_authorization_token, limit: 10, offset: 0, order_by: OrderBy::DESC, sort_by: SortBy::CREATEDDATETIME) ⇒ `ApiResponse`

Retrieve a paginated list of label branding images associated with your customer reference ID (CRID). The response may be sorted using the URL query parameters defined below. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. Authorization Token from the payments API Call. return. before returning the results. descending order. ‘imageName` or `createdDateTime`.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
limit (Integer) (defaults to: 10) —

Optional parameter: The number of items to
offset (Integer) (defaults to: 0) —

Optional parameter: The number of items to skip
order_by (OrderBy) (defaults to: OrderBy::DESC) —

Optional parameter: Sort results in ascending or
sort_by (SortBy) (defaults to: SortBy::CREATEDDATETIME) —

Optional parameter: Sort by field, e.g.,

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3622

def get_list_label_branding(scope,
                            x_payment_authorization_token,
                            limit: 10,
                            offset: 0,
                            order_by: OrderBy::DESC,
                            sort_by: SortBy::CREATEDDATETIME)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/branding',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .query_param(new_parameter(limit, key: 'limit'))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(order_by, key: 'orderBy'))
               .query_param(new_parameter(sort_by, key: 'sortBy'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelBrandingGetListOfImagesResponseWithPagination.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_package_tracking(tracking_number, scope, x_forwarded_for: nil, expand: Expand::SUMMARY, destination_zip_code: nil, mailing_date: nil) ⇒ `ApiResponse`

This API allows users to retrieve either a summary or detailed information about a specific USPS® package. Using the USPS® Tracking Request, individuals can view the delivery status of various mail items, such as Priority Mail®, Priority Mail Express®, and Package Services (including Parcel Post®, Bound Printed Matter, Library Mail, and Media Mail®) that have USPS® Tracking. By collecting mail class and service information from Product Tracking Systems, USPS® Tracking provides users with delivery status updates. By entering the tracking number, users can view the summarized or detailed delivery status of single Priority Mail® and Package Service parcels with Delivery Confirmation. By registering for the USPS® Tracking by Email service, users can receive email notifications about their package tracking events. This service allows customers to submit their email address to be notified of current or future tracking activity. Users can choose to receive notifications for all activity to date, all future activity, or both. Whenever a mail piece receives an email notifiable event, an email with the relevant information will be generated and sent. With the new request type, users can make multiple requests for a single mail piece in a single request. Tracking status can be obtained using just the impb, and if multiple items are found, users can include additional details in the request. representation of package barcode data, commonly known as its tracking number. determines the level of access and permissions for the API. The value of this parameter should be set to “tracking” for tracking-related operations. address of the originating client, in additon to intermediate proxies that have forwarded the request. If a request goes through multiple proxies, the IP addresses of each successive proxy is listed. This means, the right-most IP address is the IP address of the most recent proxy and the left-most IP address is the IP address of the originating client. be expanded as Summary or Detail. When ommitted, the tracking summary information is returned. * SUMMARY - Data returned still contains the summary information, but this information is having only one line of text

DETAIL - Data returned still contains the detail and summary

information, but this information is broken down into fields instead of having only one line of text ZIP Code™. mailed.

Parameters:

tracking_number (String) —

Required parameter: The human-readable
scope (Scope18) —

Required parameter: The scope of the request, which
x_forwarded_for (String) (defaults to: nil) —

Optional parameter: Contains the IP
expand (Expand) (defaults to: Expand::SUMMARY) —

Optional parameter: Specify the fields that are to
destination_zip_code (String) (defaults to: nil) —

Optional parameter: The destination
mailing_date (Date) (defaults to: nil) —

Optional parameter: The date the package was

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4871

def get_package_tracking(tracking_number,
                         scope,
                         x_forwarded_for: nil,
                         expand: Expand::SUMMARY,
                         destination_zip_code: nil,
                         mailing_date: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/tracking/{trackingNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_forwarded_for, key: 'X-Forwarded-For'))
               .query_param(new_parameter(expand, key: 'expand'))
               .query_param(new_parameter(destination_zip_code, key: 'destinationZIPCode'))
               .query_param(new_parameter(mailing_date, key: 'mailingDate'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(proc do |response, should_symbolize|
                  APIHelper.deserialize_union_type(
                    UnionTypeLookUp.get(:GetPackageTrackingResponse),
                    response, should_symbolize, true
                  )
                end)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#get_parcel_locker_location(scope, city: nil, state: nil, zip_code: nil, offset: 0, limit: 30) ⇒ `ApiResponse`

The Parcel Locker Locations API can be used to search for operational USPS Parcel Locker locations by city/state combination or ZIP code. Parcel lockers are uniquely identified by their facility ID, found in the ‘facilityId` field. A parcel locker’s facility ID is required when creating a label for a package destined for a parcel locker. Labels can be created via the [Domestic Labels 3.0 API](developer.usps.com/domesticlabelsv3). A complete query consists of one of the following:

City/State Pair
ZIP Code™
City/State Pair and ZIP Code™

Notes:

- Parcel locker data is broken up ("paginated") across several requests

using the ‘offset=0&limit=50` query parameters. Please see the documentation for each parameter. determines the level of access and permissions for the API. The value of this parameter should be set to “locations” for locations-related operations. Clients should URI-encode this value so that spaces are properly represented. For example, if looking for parcel lockers in “Los Angeles”, the `city` parameter’s value should look like this: ‘city=Los%20Angeles`. (Note: the space is converted to `%20`.) Notes: - If `city` is set, then `state` must also be set. The API will respond with a 400 Bad Request if `state` does not accompany `city`. for the state to search. Notes: - If `state` is set, then `city` must also be set. The API will respond with a 400 Bad Request if `city` does not accompany `state`. lockers to skip. Examples: - Given the request `GET /parcel-locker-locations?offset=0&limit=20`, if there are 100 total results, the response will contain the first 20 parcel lockers available at that ZIPCode. See the documentation on the `limit` parameter. - Given the request `GET /parcel-locker-locations?ZIPCode=56789&offset=40&limit=20`, if there are 100 total results, the API will skip the first 40 parcel lockers and respond with the next 20. - Given the request `GET /parcel-locker-locations?city=Denver&state=CO&offset=20&limit=20`, if there are 15 total results, the response will include no parcel lockers because the API skipped over all 15 lockers. to include in the response. Notes: - If the number of total results is less than `limit`, then all results are returned. - The last page will have the remaining amount of parcel lockers out of the total amount if the value of `limit` does not evenly divide by the total amount of parcel lockers that match the city/state or ZIPCode.

Parameters:

scope (Scope12) —

Required parameter: The scope of the request, which
city (String) (defaults to: nil) —

Optional parameter: This is the city to search.
state (String) (defaults to: nil) —

Optional parameter: This is the two-character code
zip_code (String) (defaults to: nil) —

Optional parameter: This is the 5-digit ZIP code. Nine-digit and eleven-digit ZIP codes are not accepted.
offset (Float) (defaults to: 0) —

Optional parameter: Specifies the number of parcel
limit (Float) (defaults to: 30) —

Optional parameter: Indicates how many parcel lockers

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4194

def get_parcel_locker_location(scope,
                               city: nil,
                               state: nil,
                               zip_code: nil,
                               offset: 0,
                               limit: 30)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/parcel-locker-locations',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(city, key: 'city'))
               .query_param(new_parameter(state, key: 'state'))
               .query_param(new_parameter(zip_code, key: 'ZIPCode'))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ParcelLockerLocation.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_payment_account_account_number(scope, account_number, account_type, permit_zip_code: nil, amount: nil) ⇒ `ApiResponse`

You can check if sufficient funds exist in the account, if you pass the amount parameter. In case you omit the amount parameter, you can still retrieve general information about the account, such as its non-profit status. determines the level of access and permissions for the API. The value of this parameter should be set to “payments” for payments-related operations. payment account payment account either Electronic Payment System account or Permit. associated to the permit number. This value is required when the account-type is ‘PERMIT’. account will be checked to see if there are sufficient funds at present to process a payment transaction for that amount.

Parameters:

scope (Scope19) —

Required parameter: The scope of the request, which
account_number (String) —

Required parameter: Account number for
account_type (AccountType11) —

Required parameter: The type of
permit_zip_code (String) (defaults to: nil) —

Optional parameter: The ZIP Code™
amount (Float) (defaults to: nil) —

Optional parameter: If amount is supplied, the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5205

def get_payment_account_account_number(scope,
                                       account_number,
                                       account_type,
                                       permit_zip_code: nil,
                                       amount: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/payment-account/{account-number}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(account_number, key: 'account-number')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(account_type, key: 'accountType')
                             .is_required(true))
               .query_param(new_parameter(permit_zip_code, key: 'permitZIPCode'))
               .query_param(new_parameter(amount, key: 'amount'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PaymentsPaymentAccount.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Not found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_post_office_location(scope, street_address: nil, secondary_address: nil, city: nil, state: nil, urbanization: nil, zip_code: nil, zip_plus4: nil, lat: nil, long: nil, post_office_type: nil, mailing_service: nil, business_service: nil, passport_service: nil, pickup_service: nil, financial_service: nil, hours: nil, radius: 20, length: nil, width: nil, height: nil, offset: nil, limit: 20) ⇒ `ApiResponse`

A complete query consists of one of the following:

* Complete domestic address
* City/State Pair
* ZIP Code&#8482;
* Latitude/Longitude pair

Users can provide additional filters such as a radius (distance and units, defaults to 20 miles), location type, desired services, open times, and package dimensions. determines the level of access and permissions for the API. The value of this parameter should be set to “locations” for locations-related operations. building along with the name of the road or street on which it is located. designator, such as apartment(APT) or suite(STE) number, defining the exact location of the address within a building. For more information please see [Postal Explorer](pe.usps.com/text/pub28/28c2_003.htm). address. of the address. code relevant only for Puerto Rico addresses. code. component of the ZIP+4 code. Using the correct Zip+4 reduces the number of times your mail is handled and can decrease the chance of a misdelivery or error. type of post office requested. Service supported at the facility Business Service supported at the facility Passport Service supported at the facility Service supported at the facility. If requesting PICKUP_PARCEL_LOCKER then the length, width and height parameters are always required. Financial Service supported at the facility. Locations to those supporting Retail Services at the enumerated times. If not provided, all with be returned. from the location given to the respective Post Office. If no radius is provided a default radius of 20 miles will be used inches. The maximum dimension is always length. inches. The second longest dimension is always width. inches. before returning the results

Parameters:

scope (Scope12) —

Required parameter: The scope of the request, which
street_address (String) (defaults to: nil) —

Optional parameter: The number of a
secondary_address (String) (defaults to: nil) —

Optional parameter: The secondary unit
city (String) (defaults to: nil) —

Optional parameter: This is the city name of the
state (String) (defaults to: nil) —

Optional parameter: This is two-character state code
urbanization (String) (defaults to: nil) —

Optional parameter: This is the urbanization
zip_code (String) (defaults to: nil) —

Optional parameter: This is the 5-digit ZIP
zip_plus4 (String) (defaults to: nil) —

Optional parameter: This is the 4-digit
lat (Float) (defaults to: nil) —

Optional parameter: The latitude geo coordinate.
long (Float) (defaults to: nil) —

Optional parameter: The longitude geo coordinate.
post_office_type (Array[PostOfficeType1]) (defaults to: nil) —

Optional parameter: The
mailing_service (Array[MailingService]) (defaults to: nil) —

Optional parameter: Mailing
business_service (Array[BusinessService]) (defaults to: nil) —

Optional parameter:
passport_service (Array[PassportService]) (defaults to: nil) —

Optional parameter:
pickup_service (Array[PickupService]) (defaults to: nil) —

Optional parameter: Pick-Up
financial_service (Array[FinancialService]) (defaults to: nil) —

Optional parameter:
hours (Hours) (defaults to: nil) —

Optional parameter: Limit the response Post Office
radius (Integer) (defaults to: 20) —

Optional parameter: The max distance (in miles)
length (Float) (defaults to: nil) —

Optional parameter: This is the package length in
width (Float) (defaults to: nil) —

Optional parameter: This is the package width in
height (Float) (defaults to: nil) —

Optional parameter: This is the package height in
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4064

def get_post_office_location(scope,
                             street_address: nil,
                             secondary_address: nil,
                             city: nil,
                             state: nil,
                             urbanization: nil,
                             zip_code: nil,
                             zip_plus4: nil,
                             lat: nil,
                             long: nil,
                             post_office_type: nil,
                             mailing_service: nil,
                             business_service: nil,
                             passport_service: nil,
                             pickup_service: nil,
                             financial_service: nil,
                             hours: nil,
                             radius: 20,
                             length: nil,
                             width: nil,
                             height: nil,
                             offset: nil,
                             limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/post-office-locations',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(street_address, key: 'streetAddress'))
               .query_param(new_parameter(secondary_address, key: 'secondaryAddress'))
               .query_param(new_parameter(city, key: 'city'))
               .query_param(new_parameter(state, key: 'state'))
               .query_param(new_parameter(urbanization, key: 'urbanization'))
               .query_param(new_parameter(zip_code, key: 'ZIPCode'))
               .query_param(new_parameter(zip_plus4, key: 'ZIPPlus4'))
               .query_param(new_parameter(lat, key: 'LAT'))
               .query_param(new_parameter(long, key: 'LONG'))
               .query_param(new_parameter(post_office_type, key: 'postOfficeType'))
               .query_param(new_parameter(mailing_service, key: 'mailingService'))
               .query_param(new_parameter(business_service, key: 'businessService'))
               .query_param(new_parameter(passport_service, key: 'passportService'))
               .query_param(new_parameter(pickup_service, key: 'pickupService'))
               .query_param(new_parameter(financial_service, key: 'financialService'))
               .query_param(new_parameter(hours, key: 'hours'))
               .query_param(new_parameter(radius, key: 'radius'))
               .query_param(new_parameter(length, key: 'length'))
               .query_param(new_parameter(width, key: 'width'))
               .query_param(new_parameter(height, key: 'height'))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3PostOfficeLocationsResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid Address Information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#get_rate_list(scope, body: nil) ⇒ `ApiResponse`

Given size/weight/destination of pieces, returns a list of potential rates. Can also search for contract rates by providing mailer id, EPS, permit number or vendor number and account. If searching for contract rates, then a specified mail class is required. determines the level of access and permissions for the API. The value of this parameter should be set to “international-prices” for international-prices-related operations. parameters to be used for the query.

Parameters:

scope (Scope9) —

Required parameter: The scope of the request, which
body (InternationalRateListQuery) (defaults to: nil) —

Optional parameter: The search

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2785

def get_rate_list(scope,
                  body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/base-rates-list/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalRateListQueryResult.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_reconciliation_adjustments(scope, crid, event_type, start_date, start_time, end_date, end_time, page_num: 20, page_size: 20) ⇒ `ApiResponse`

The Reconciliation Adjustments API enables users to receive USPS Ship adjustments by a Package Identification Code (PIC) aka Tracking Number. determines the level of access and permissions for the API. The value of this parameter should be set to “reconciliation-adjustments” for reconciliation-adjustments-related operations. type. representation of start date the reconciliation adjustment event occurred, in the format of YYYYMMDD. representation of start time the reconciliation adjustment event occurred, in the format of HHMMSS. representation of end date the reconciliation adjustment event occurred, in the format of YYYYMMDD. representation of end time the reconciliation adjustment event occurred, in the format of HHMMSS. return

Parameters:

scope (Scope21) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: Filter by CRID.
event_type (AdjustmentSubtype) —

Required parameter: Filter by event
start_date (String) —

Required parameter: The human-readable
start_time (String) —

Required parameter: The human-readable
end_date (String) —

Required parameter: The human-readable
end_time (String) —

Required parameter: The human-readable
page_num (Integer) (defaults to: 20) —

Optional parameter: The page number to return
page_size (Integer) (defaults to: 20) —

Optional parameter: The number of items to

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5342

def get_reconciliation_adjustments(scope,
                                   crid,
                                   event_type,
                                   start_date,
                                   start_time,
                                   end_date,
                                   end_time,
                                   page_num: 20,
                                   page_size: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/reconciliation-adjustments/{CRID}/{eventType}/{startDate}/{startTime}/{endDate}/{endTime}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(event_type, key: 'eventType')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(start_date, key: 'startDate')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(start_time, key: 'startTime')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(end_date, key: 'endDate')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(end_time, key: 'endTime')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(page_num, key: 'pageNum'))
               .query_param(new_parameter(page_size, key: 'pageSize'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3ReconciliationAdjustmentsEventTypeStartDateStartTimeEndDateEndTimeResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_return_valid_zip5_codes(scope) ⇒ `ApiResponse`

**Return valid 5-digit Origin and Destination ZIP codes that have service standards associated with them and are not exempt. determines the level of access and permissions for the API. The value of this parameter should be set to “service-standards-directory” for service-standards-directory-related operations.

Parameters:

scope (Scope24) —

Required parameter: The scope of the request, which

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5746

def get_return_valid_zip5_codes(scope)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/zip5Codes',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Zip5CodesResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource not found.',
                             AddressesErrorException)
                .local_error('500',
                             'Internal server error.',
                             AddressesErrorException))
    .execute
end

#get_service_standards(scope, origin_zip_code, destination_zip_code, mail_class: nil, destination_type: DestinationType::STREET, service_type_codes: nil, destination_entry_facility_type: nil, weight: nil, length: nil, height: nil, width: nil, dimensions_uom: DimensionsUom::ENUM_IN, rate_holder_crid: nil, presort: false) ⇒ `ApiResponse`

Returns the average number of days it will take a package to arrive at its destination for the selected mail class. When requesting standards for USPS_GROUND_ADVANTAGE two standards will be returned (one for packages greater than or equal to a pound and one for packages less than a pound, this will be called out in the notes field), unless a weight is provided. determines the level of access and permissions for the API. The value of this parameter should be set to “service-standards” for service-standards-related operations. where the package is shipped from using either all 9 digits, 5 digits, or first 3 digits. Code™ where the package is shipped to using either all 9 digits or 5 digits. divides mail into different services, called “classes.” Each class of mail has different features, service levels, postage prices, and presort requirements. Note: Mail class enumerations “LETTERS”, “CARDS”, and FLATS“ are specific to First Class Mail only. type indicator for non-expedited mailing. Defaults to ‘STREET’ if omitted. are designators used to represent USPS classes of mail in conjunction with the type of Extra Service(s) being requested. For valid Service Type Code options, please refer to the [Service Type Code list](postalpro.usps.com/IMPB_Service_Type_Codes). Optional parameter: Types of Facilities: * NONE * DESTINATION_NETWORK_DISTRIBUTION_CENTER * DESTINATION_SECTIONAL_CENTER_FACILITY * DESTINATION_DELIVERY_UNIT * DESTINATION_SERVICE_HUB shipped. Required if looking up ‘USPS_GROUND_ADVANTAGE` estimates or standards. For getting estimates with `USPS_GROUND_ADVANTAGE`, if the package weight is greater than one pound then weight will be required. dimensionsUOM. If partial dimensions are provided, an error response will return. `length`, `width`, and `height` are required only for Priority Mail Next Day packages. dimensionsUOM. If partial dimensions are provided, an error response will return. `length`, `width`, and `height` are required only for Priority Mail Next Day packages. dimensionsUOM. If partial dimensions are provided, an error response will return. `length`, `width`, and `height` are required only for Priority Mail Next Day packages. of measure * in - Inches ID (CRID) associated with the business or mailer. whether the Presort feature is to be used for this mail piece. Presort is only available for `mailClass` values of `LETTERS`, `FLATS`, or `CARDS`.

Parameters:

scope (Scope23) —

Required parameter: The scope of the request, which
origin_zip_code (String) —

Required parameter: The ZIP Code™
destination_zip_code (String) —

Required parameter: The ZIP
mail_class (MailClass8) (defaults to: nil) —

Optional parameter: The Postal Service
destination_type (DestinationType) (defaults to: DestinationType::STREET) —

Optional parameter: Destination
service_type_codes (String) (defaults to: nil) —

Optional parameter: Service Type Codes
destination_entry_facility_type (DestinationEntryFacilityType4) (defaults to: nil)
weight (Float) (defaults to: nil) —

Optional parameter: The weight of the package being
length (Float) (defaults to: nil) —

Optional parameter: The length of the container, in
height (Float) (defaults to: nil) —

Optional parameter: The height of the container, in
width (Float) (defaults to: nil) —

Optional parameter: The width of the container, in
dimensions_uom (DimensionsUom) (defaults to: DimensionsUom::ENUM_IN) —

Optional parameter: Dimensions unit
rate_holder_crid (String) (defaults to: nil) —

Optional parameter: Customer Registration
presort (TrueClass | FalseClass) (defaults to: false) —

Optional parameter: Indicates

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5675

def get_service_standards(scope,
                          origin_zip_code,
                          destination_zip_code,
                          mail_class: nil,
                          destination_type: DestinationType::STREET,
                          service_type_codes: nil,
                          destination_entry_facility_type: nil,
                          weight: nil,
                          length: nil,
                          height: nil,
                          width: nil,
                          dimensions_uom: DimensionsUom::ENUM_IN,
                          rate_holder_crid: nil,
                          presort: false)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/standards',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(origin_zip_code, key: 'originZIPCode')
                             .is_required(true))
               .query_param(new_parameter(destination_zip_code, key: 'destinationZIPCode')
                             .is_required(true))
               .query_param(new_parameter(mail_class, key: 'mailClass'))
               .query_param(new_parameter(destination_type, key: 'destinationType'))
               .query_param(new_parameter(service_type_codes, key: 'serviceTypeCodes'))
               .query_param(new_parameter(destination_entry_facility_type, key: 'destinationEntryFacilityType'))
               .query_param(new_parameter(weight, key: 'weight'))
               .query_param(new_parameter(length, key: 'length'))
               .query_param(new_parameter(height, key: 'height'))
               .query_param(new_parameter(width, key: 'width'))
               .query_param(new_parameter(dimensions_uom, key: 'dimensionsUOM'))
               .query_param(new_parameter(rate_holder_crid, key: 'rateHolderCRID'))
               .query_param(new_parameter(presort, key: 'presort'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Standard.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Bad Request',
                             ServiceStandardsErrorException)
                .local_error('401',
                             'Unauthorized request',
                             ServiceStandardsErrorException)
                .local_error('403',
                             'Access is denied',
                             ServiceStandardsErrorException)
                .local_error('404',
                             'Resource Not Found',
                             ServiceStandardsErrorException)
                .local_error('503',
                             'Service Unavailable',
                             ServiceStandardsErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_service_standards_estimates(scope, origin_zip_code, destination_zip_code, acceptance_date: nil, acceptance_time: nil, mail_class: nil, destination_type: DestinationType::STREET, service_type_codes: nil, destination_entry_facility_type: nil, weight: nil, weight_uom: WeightUom::LB, length: nil, height: nil, width: nil, dimensions_uom: DimensionsUom::ENUM_IN, rate_holder_crid: nil, presort: false) ⇒ `ApiResponse`

Allows customers to get estimates on delivery standards between 3 or 5 digit ZIP Code™s for the selected mail classes. When requesting estimates for USPS_GROUND_ADVANTAGE two estimates will be returned (one for packages greater than or equal to a pound and one for packages less than a pound. This will be called out in the notes field) unless a weight is provided. determines the level of access and permissions for the API. The value of this parameter should be set to “service-standards” for service-standards-related operations. where the package is shipped from using either all 9 digits, 5 digits, or first 3 digits. Code™ where the package is shipped to using either all 9 digits or 5 digits. mailed. Acceptance date may be up to 30 days in advance. Today’s date is used if omitted. mailed. Today’s time defaults to 8:00 am if omitted. divides mail into different services, called “classes.” Each class of mail has different features, service levels, postage prices, and presort requirements. Note: Mail class enumerations “LETTERS”, “CARDS”, and FLATS“ are specific to First Class Mail only. type indicator for non-expedited mailing. Defaults to ‘STREET’ if omitted. are designators used to represent USPS classes of mail in conjunction with the type of Extra Service(s) being requested. For valid Service Type Code options, please refer to the [Service Type Code list](postalpro.usps.com/IMPB_Service_Type_Codes). Optional parameter: Types of Facilities: * NONE * DESTINATION_NETWORK_DISTRIBUTION_CENTER * DESTINATION_SECTIONAL_CENTER_FACILITY * DESTINATION_DELIVERY_UNIT * DESTINATION_SERVICE_HUB shipped. For getting estimates with ‘USPS_GROUND_ADVANTAGE`, if the package weight is greater than one pound then weight will be required. `weight` is also required for Priority Mail Next Day packages and must be no greater than 20 pounds. If the package is greater than 20 pounds, it will be treated as standard Priority Mail. Measurement * lb - Pounds dimensionsUOM. If partial dimensions are provided, an error response will return. `length`, `width`, and `height` are required only for Priority Mail Next Day packages. dimensionsUOM. If partial dimensions are provided, an error response will return. `length`, `width`, and `height` are required only for Priority Mail Next Day packages. dimensionsUOM. If partial dimensions are provided, an error response will return. `length`, `width`, and `height` are required only for Priority Mail Next Day packages. of measure * in - Inches ID (CRID) associated with the business or mailer. whether the Presort feature is to be used for this mail piece. Presort is only available for `mailClass` values of `LETTERS`, `FLATS`, or `CARDS`.

Parameters:

scope (Scope23) —

Required parameter: The scope of the request, which
origin_zip_code (String) —

Required parameter: The ZIP Code™
destination_zip_code (String) —

Required parameter: The ZIP
acceptance_date (Date) (defaults to: nil) —

Optional parameter: Date Package will be
acceptance_time (String) (defaults to: nil) —

Optional parameter: Time Package will be
mail_class (MailClass8) (defaults to: nil) —

Optional parameter: The Postal Service
destination_type (DestinationType) (defaults to: DestinationType::STREET) —

Optional parameter: Destination
service_type_codes (String) (defaults to: nil) —

Optional parameter: Service Type Codes
destination_entry_facility_type (DestinationEntryFacilityType4) (defaults to: nil)
weight (Float) (defaults to: nil) —

Optional parameter: The weight of the package being
weight_uom (WeightUom) (defaults to: WeightUom::LB) —

Optional parameter: Weight Unit of
length (Float) (defaults to: nil) —

Optional parameter: The length of the container, in
height (Float) (defaults to: nil) —

Optional parameter: The height of the container, in
width (Float) (defaults to: nil) —

Optional parameter: The width of the container, in
dimensions_uom (DimensionsUom) (defaults to: DimensionsUom::ENUM_IN) —

Optional parameter: Dimensions unit
rate_holder_crid (String) (defaults to: nil) —

Optional parameter: Customer Registration
presort (TrueClass | FalseClass) (defaults to: false) —

Optional parameter: Indicates

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5548

def get_service_standards_estimates(scope,
                                    origin_zip_code,
                                    destination_zip_code,
                                    acceptance_date: nil,
                                    acceptance_time: nil,
                                    mail_class: nil,
                                    destination_type: DestinationType::STREET,
                                    service_type_codes: nil,
                                    destination_entry_facility_type: nil,
                                    weight: nil,
                                    weight_uom: WeightUom::LB,
                                    length: nil,
                                    height: nil,
                                    width: nil,
                                    dimensions_uom: DimensionsUom::ENUM_IN,
                                    rate_holder_crid: nil,
                                    presort: false)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/estimates',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(origin_zip_code, key: 'originZIPCode')
                             .is_required(true))
               .query_param(new_parameter(destination_zip_code, key: 'destinationZIPCode')
                             .is_required(true))
               .query_param(new_parameter(acceptance_date, key: 'acceptanceDate'))
               .query_param(new_parameter(acceptance_time, key: 'acceptanceTime'))
               .query_param(new_parameter(mail_class, key: 'mailClass'))
               .query_param(new_parameter(destination_type, key: 'destinationType'))
               .query_param(new_parameter(service_type_codes, key: 'serviceTypeCodes'))
               .query_param(new_parameter(destination_entry_facility_type, key: 'destinationEntryFacilityType'))
               .query_param(new_parameter(weight, key: 'weight'))
               .query_param(new_parameter(weight_uom, key: 'weightUOM'))
               .query_param(new_parameter(length, key: 'length'))
               .query_param(new_parameter(height, key: 'height'))
               .query_param(new_parameter(width, key: 'width'))
               .query_param(new_parameter(dimensions_uom, key: 'dimensionsUOM'))
               .query_param(new_parameter(rate_holder_crid, key: 'rateHolderCRID'))
               .query_param(new_parameter(presort, key: 'presort'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Estimate.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Bad Request',
                             ServiceStandardsErrorException)
                .local_error('401',
                             'Unauthorized request',
                             ServiceStandardsErrorException)
                .local_error('403',
                             'Access is denied',
                             ServiceStandardsErrorException)
                .local_error('404',
                             'Resource Not Found',
                             ServiceStandardsErrorException)
                .local_error('503',
                             'Service Unavailable',
                             ServiceStandardsErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_single_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ `ApiResponse`

Retrieve a label branding image associated with your customer reference ID (CRID). The CRID will be taken from the ‘LABEL_OWNER` role of your Payment Authorization token. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. branding image Authorization Token from the payments API Call.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
image_uuid (String) —

Required parameter: The UUID of a label
x_payment_authorization_token (String) —

Required parameter: Payment

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3681

def get_single_label_branding(scope,
                              image_uuid,
                              x_payment_authorization_token)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/branding/{imageUUID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(image_uuid, key: 'imageUUID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelBrandingGetImageResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_single_package_campaign(scope, crid, campaign_id) ⇒ `ApiResponse`

Retrieve details of a single Informed Delivery package campaign by CRID and campaign ID determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-package-campaigns” for informed-delivery-package-campaigns-related operations. Registration ID (CRID). campaign.

Parameters:

scope (Scope7) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
campaign_id (String) —

Required parameter: Unique identifier for the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2209

def get_single_package_campaign(scope,
                                crid,
                                campaign_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SinglePackageCampaignResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryPackageCampaignsQueryErrorResponseException))
    .execute
end

#get_subscriptions_adjustment(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

Get list of all Adjustment Subscriptions you have created, by CRID determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-adjustments” for subscriptions-adjustments-related operations. separated list of values. before returning the results

Parameters:

scope (Scope28) —

Required parameter: The scope of the request, which
crid (Array[String]) —

Required parameter: Filter by CRID. Comma
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5956

def get_subscriptions_adjustment(scope,
                                 crid,
                                 offset: nil,
                                 limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(crid, key: 'CRID')
                             .is_required(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3SubscriptionsResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid label request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#get_subscriptions_adjustment_id(scope, subscription_id) ⇒ `ApiResponse`

Get a previously created subscription by its unique id. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-adjustments” for subscriptions-adjustments-related operations. of the subscription.

Parameters:

scope (Scope28) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6058

def get_subscriptions_adjustment_id(scope,
                                    subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsAdjustmentsSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_dispute(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

Get list of all Disputes Subscriptions you have created, by CRID determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-disputes” for subscriptions-disputes-related operations. separated list of values. before returning the results

Parameters:

scope (Scope29) —

Required parameter: The scope of the request, which
crid (Array[String]) —

Required parameter: Filter by CRID. Comma
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6227

def get_subscriptions_dispute(scope,
                              crid,
                              offset: nil,
                              limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(crid, key: 'CRID')
                             .is_required(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3SubscriptionsResponse1.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid label request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#get_subscriptions_dispute_id(scope, subscription_id) ⇒ `ApiResponse`

Get a previously created subscription by its unique id. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-disputes” for subscriptions-disputes-related operations. of the subscription.

Parameters:

scope (Scope29) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6329

def get_subscriptions_dispute_id(scope,
                                 subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsDisputesSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_ncoa(scope, crid: nil, offset: nil, limit: 20) ⇒ `ApiResponse`

Get list of all NCOA Subscriptions you have created, by CRID. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-ncoa” for subscriptions-ncoa-related operations. list of values. before returning the results

Parameters:

scope (Scope30) —

Required parameter: The scope of the request, which
crid (String) (defaults to: nil) —

Optional parameter: Filter by CRID. Comma-separated
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6498

def get_subscriptions_ncoa(scope,
                           crid: nil,
                           offset: nil,
                           limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(crid, key: 'CRID'))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid label request information.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_ncoa_id(scope, subscription_id) ⇒ `ApiResponse`

Get a previously created subscription by its unique id. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-ncoa” for subscriptions-ncoa-related operations. of the subscription.

Parameters:

scope (Scope30) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6598

def get_subscriptions_ncoa_id(scope,
                              subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsNcoaSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_package_transaction_details(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

Get list of all Package Transaction Details Subscriptions you have created, by CRID determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-package-transaction-details” for subscriptions-package-transaction-details-related operations. separated list of values. before returning the results

Parameters:

scope (Scope31) —

Required parameter: The scope of the request, which
crid (Array[String]) —

Required parameter: Filter by CRID. Comma
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6769

def get_subscriptions_package_transaction_details(scope,
                                                  crid,
                                                  offset: nil,
                                                  limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(crid, key: 'CRID')
                             .is_required(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3SubscriptionsResponse2.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid label request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#get_subscriptions_package_transaction_details_id(scope, subscription_id) ⇒ `ApiResponse`

Get a previously created subscription by its unique id. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-package-transaction-details” for subscriptions-package-transaction-details-related operations. of the subscription.

Parameters:

scope (Scope31) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6873

def get_subscriptions_package_transaction_details_id(scope,
                                                     subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsPackageTransactionDetailsSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_tracking(scope, mid: nil, tracking_number: nil, offset: nil, limit: 20) ⇒ `ApiResponse`

Get list of all Tracking Subscriptions you have created, by MID or Tracking Number. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-tracking” for subscriptions-tracking-related operations. Comma-separated list of values. tracking number. Comma-separated list of values. before returning the results

Parameters:

scope (Scope32) —

Required parameter: The scope of the request, which
mid (Array[String]) (defaults to: nil) —

Optional parameter: Filter by MID.
tracking_number (Array[String]) (defaults to: nil) —

Optional parameter: Filter by
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7048

def get_subscriptions_tracking(scope,
                               mid: nil,
                               tracking_number: nil,
                               offset: nil,
                               limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(mid, key: 'MID'))
               .query_param(new_parameter(tracking_number, key: 'trackingNumber'))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(V3SubscriptionsResponse3.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid label request information.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_tracking_id(scope, subscription_id) ⇒ `ApiResponse`

Get a previously created subscription by its unique id. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-tracking” for subscriptions-tracking-related operations. of the subscription.

Parameters:

scope (Scope32) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7151

def get_subscriptions_tracking_id(scope,
                                  subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsTrackingSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_unpaid_packages(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

“Get list of all Unpaid Packages Subscriptions you have created, by CRID” determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-unpaid-packages” for subscriptions-unpaid-packages-related operations. Comma-separated list of values. before returning the results

Parameters:

scope (Scope33) —

Required parameter: The scope of the request, which
crid (Array[String]) —

Required parameter: Filter by CRID.
offset (Integer) (defaults to: nil) —

Optional parameter: The number of items to skip
limit (Integer) (defaults to: 20) —

Optional parameter: The number of items to return

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7320

def get_subscriptions_unpaid_packages(scope,
                                      crid,
                                      offset: nil,
                                      limit: 20)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(crid, key: 'CRID')
                             .is_required(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsUnpaidPackagesSubscription.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Invalid label request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_subscriptions_unpaid_packages_id(scope, subscription_id) ⇒ `ApiResponse`

Get a previously created subscription by its unique id. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-unpaid-packages” for subscriptions-unpaid-packages-related operations. of the subscription.

Parameters:

scope (Scope33) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7423

def get_subscriptions_unpaid_packages_id(scope,
                                         subscription_id)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsUnpaidPackagesSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_summary_data(scope, crid, callback_key) ⇒ `ApiResponse`

Return summary-level information on a single callback key transaction determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). associated with the campaign.

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
callback_key (String) —

Required parameter: The callback key

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1935

def get_summary_data(scope,
                     crid,
                     callback_key)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}/{callbackKey}/summary',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(callback_key, key: 'callbackKey')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SummarySuccessResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsQueryErrorResponseException))
    .execute
end

#get_user_profile(scope) ⇒ `ApiResponse`

Get user account profile information. Based on the 'OpenID Connect Core 1.0', Final, November 2014, see [OpenID Foundation](openid.net/specs/openid-connect-core-1_0.html#UserInfo ). For userinfo, see openid.net/specs/openid-connect-core-1_0.html#UserInfo. Must use the Bearer authentication scheme.

```
Authorization: Bearer

eyJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJ1c3BzLmNvbSIsInN1YiI6IjI0ODI4OTc2MTAwMSIsI mF1ZCI6InM2QmhkUmtxdDMiLCJub25jZSI6Im4tMFM2X1d6QTJNaiIsImV4cCI6MTMxMTI4MTk 3MCwiaWF0IjoxMzExMjgwOTcwLCJuYW1lIjoiSmFuZSBEb2UiLCJnaXZlbl9uYW1lIjoiSmFuZ SIsImZhbWlseV9uYW1lIjoiRG9lIiwibG9jYWxlIjoiZW4tdXMiLCJhenAiOiJ1c3BzLmNvbSI sImFjciI6IkFBTDEiLCJhbXIiOiJwd2QifQ.qJ2SUGKn4TabFfMYODW1RLxirFmeeYPDyFvuJR 0ywRVaRnoe7Rlk8yKM3v2fCBUi2lMo00whNhNWmqQktpGgvkVGWXGMNIlVxJCqt_aPFx3oOvkh KWGI49JI5NyXrpj4tfYD5pIYbrihkF7eMYG3XyqYMx1VLhhV0PmWhpq787K7_AGfRlNVQnD_WE HJt4SoEnsiw8vcwDWXcXr5yCzAEn8mfCSTlamqVBUyey1Fyg_xgQIRj_b9CO-O4kXsBM3vqo5C O2qET2tRd37niaQvV-g418sEpnw1iAtxWfcyU4IIjWlQa7AxAc3T4Vx6XOwn1CNI22ZhdaBskU tD-EexWQ

```

determines the level of access and permissions for the API. The value of this parameter should be set to “oauth2-oidc” for oauth2-oidc-related operations.

Parameters:

scope (Scope34) —

Required parameter: The scope of the request, which

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7606

def get_user_profile(scope)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/userinfo',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ResourceOwnerUserClaims.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  Check the input parameters and values.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized Request.  Check the authentication scheme and'\
                              ' values being used to make the request.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#get_zip_code(scope, street_address, city, state, firm: nil, secondary_address: nil, zip_code: nil, zip_plus4: nil) ⇒ `ApiResponse`

Returns the ZIP Code™ and ZIP + 4® corresponding to the given address, city, and state (use USPS state abbreviations). determines the level of access and permissions for the API. The value of this parameter should be set to “addresses” for addresses-related operations. building along with the name of the road or street on which it is located. address. code of the address. the address. designator, such as apartment(APT) or suite(STE) number, defining the exact location of the address within a building. For more information please see [Postal Explorer](pe.usps.com/text/pub28/28c2_003.htm). code. component of the ZIP+4 code. Using the correct ZIP+4 reduces the number of times your mail is handled and can decrease the chance of a misdelivery or error.

Parameters:

scope (Scope) —

Required parameter: The scope of the request, which
street_address (String) —

Required parameter: The number of a
city (String) —

Required parameter: This is the city name of the
state (String) —

Required parameter: This is the two-character state
firm (String) (defaults to: nil) —

Optional parameter: Firm/business corresponding to
secondary_address (String) (defaults to: nil) —

Optional parameter: The secondary unit
zip_code (String) (defaults to: nil) —

Optional parameter: This is the 5-digit ZIP
zip_plus4 (String) (defaults to: nil) —

Optional parameter: This is the 4-digit

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 172

def get_zip_code(scope,
                 street_address,
                 city,
                 state,
                 firm: nil,
                 secondary_address: nil,
                 zip_code: nil,
                 zip_plus4: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/zipcode',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(street_address, key: 'streetAddress')
                             .is_required(true))
               .query_param(new_parameter(city, key: 'city')
                             .is_required(true))
               .query_param(new_parameter(state, key: 'state')
                             .is_required(true))
               .query_param(new_parameter(firm, key: 'firm'))
               .query_param(new_parameter(secondary_address, key: 'secondaryAddress'))
               .query_param(new_parameter(zip_code, key: 'ZIPCode'))
               .query_param(new_parameter(zip_plus4, key: 'ZIPPlus4'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ZipCode8482Response.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#patch_label_branding(scope, image_uuid, x_payment_authorization_token, body) ⇒ `ApiResponse`

Rename the previously uploaded Label Branding Image associated with your customer reference ID (CRID). The CRID will be taken from the ‘LABEL_OWNER` role of your Payment Authorization token. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. branding image Authorization Token from the payments API Call. description here

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
image_uuid (String) —

Required parameter: The UUID of a label
x_payment_authorization_token (String) —

Required parameter: Payment
body (Array[LabelsJsonPatchRequest]) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3793

def patch_label_branding(scope,
                         image_uuid,
                         x_payment_authorization_token,
                         body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PATCH,
                                 '/{scope}/v3/branding/{imageUUID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(image_uuid, key: 'imageUUID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelBrandingImagePatchResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#patch_label_edit(scope, tracking_number, x_payment_authorization_token, body) ⇒ `ApiResponse`

Allow customers to edit package attributes for previously created labels including weight, dimensions, rate indicator, processing category and containers. These fields eligible for editing will not impact label images, so previous label images can still be used. Changing these rate ingredients may affect the prices of the label. Therefore, the Payment Authorization token is required. Note: Label edits will not be supported for the following scenarios; instead, unused label refunds should be requested and new labels should be created.

All label edits are disallowed if the original label was created with

‘suppressPostage = false`.

No dimensional updates are supported for Cubic Soft Pack labels.
Cubic labels cannot be edited to non-cubic rate indicators.

determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. the domestic label. Authorization Token from the payments API Call. type description here

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
tracking_number (String) —

Required parameter: The tracking number of
x_payment_authorization_token (String) —

Required parameter: Payment
body (Array[LabelsJsonPatchRequest1]) —

Required parameter: TODO:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3307

def patch_label_edit(scope,
                     tracking_number,
                     x_payment_authorization_token,
                     body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PATCH,
                                 '/{scope}/v3/label/{trackingNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelMetadata.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_add_imb(scope, crid, campaign_id, body) ⇒ `ApiResponse`

Add IMBs to an existing NON-SEQ campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). Informed Delivery campaign, generated internally by Informed Delivery and returned for successfully created campaigns. here

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
campaign_id (String) —

Required parameter: Unique identifier for an
body (ImBsRequest) —

Required parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1811

def post_add_imb(scope,
                 crid,
                 campaign_id,
                 body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}/pieces',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ImBsResponseLessThan25Success.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             APIException))
    .execute
end

#post_base_rates_search(scope, body: nil) ⇒ `ApiResponse`

Returns an eligible price given a set of package rate ingredients. determines the level of access and permissions for the API. The value of this parameter should be set to “prices” for prices-related operations. be used for the query.

Parameters:

scope (Scope5) —

Required parameter: The scope of the request, which
body (BaseRatesQuery) (defaults to: nil) —

Optional parameter: The search parameters to

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1048

def post_base_rates_search(scope,
                           body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/base-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PricesBaseRatesQueryResult1.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_campaigns(scope, crid, body) ⇒ `ApiResponse`

Create a new Informed Delivery campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID).

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
body (Campaign) —

Required parameter: TODO: type description here

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1404

def post_campaigns(scope,
                   crid,
                   body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/campaigns/{CRID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Campaign.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsErrorException)
                .local_error('401',
                             'Unauthorized',
                             InformedDeliveryCampaignsErrorException)
                .local_error('403',
                             'Forbidden',
                             InformedDeliveryCampaignsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             InformedDeliveryCampaignsErrorException)
                .local_error('503',
                             'Service Unavailable',
                             InformedDeliveryCampaignsErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

#post_campaigns1(scope, crid, body) ⇒ `ApiResponse`

Create a new Informed Delivery package campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-package-campaigns” for informed-delivery-package-campaigns-related operations. Customer Registration ID (CRID). here

Parameters:

scope (Scope7) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The Package campaign submitter’s
body (PackageCampaign) —

Required parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2036

def post_campaigns1(scope,
                    crid,
                    body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/campaigns/{CRID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PackageCampaign.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryPackageCampaignsErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

#post_carrier_pickup(scope, body) ⇒ `ApiResponse`

Schedule a carrier pickup on a specified date. You can schedule pickups Monday - Saturday until 2:00 AM CT on the day of the pickup. After 2:00 AM CT, same-day pickup is not available. If the address is eligible for carrier pickup, then you can schedule your pickup up to one year in advance. determines the level of access and permissions for the API. The value of this parameter should be set to “pickup” for pickup-related operations. description here

Parameters:

scope (Scope3) —

Required parameter: The scope of the request, which
body (ScheduleCarrierPickupRequest) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 576

def post_carrier_pickup(scope,
                        body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/carrier-pickup',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PickupConfirmation.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PickupErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PickupErrorException)
                .local_error('403',
                             'Access is denied.',
                             PickupErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PickupErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             PickupErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_close(scope, x_payment_authorization_token, container_id, body) ⇒ `ApiResponse`

Allows the caller to close a container and generate a manifest. determines the level of access and permissions for the API. The value of this parameter should be set to “pmod” for pmod-related operations. Authorization Token from the payments API Call. container. This is the IMpb tracking number when impbContainerType is ‘OPEN_DISTRIBUTE_PALLET.’ For all other containers, this is the container ID. description here

Parameters:

scope (Scope17) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
container_id (String) —

Required parameter: Container ID for the OD
body (CloseOdContainerRequest) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4776

def post_close(scope,
               x_payment_authorization_token,
               container_id,
               body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/pmod/manifest/{container-id}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .template_param(new_parameter(container_id, key: 'container-id')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CloseOpenAndDistributeContainerResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PmodErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PmodErrorException)
                .local_error('403',
                             'Access is denied.',
                             PmodErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PmodErrorException)
                .local_error('503',
                             'Service is unavailable',
                             PmodErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_containers(scope, body: nil) ⇒ `ApiResponse`

Allows the caller to get a container label and associate packages to that container. determines the level of access and permissions for the API. The value of this parameter should be set to “containers” for containers-related operations. description here

Parameters:

scope (Scope4) —

Required parameter: The scope of the request, which
body (ContainersContainer) (defaults to: nil) —

Optional parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 957

def post_containers(scope,
                    body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/containers',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:dynamic_deserializer))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             ContainersErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             ContainersErrorException)
                .local_error('403',
                             'Access is denied.',
                             ContainersErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             ContainersErrorException)
                .local_error('503',
                             'Service is unavailable',
                             ContainersErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_containers_with_container_id(scope, container_id, body: nil) ⇒ `ApiResponse`

This endpoint allows the caller to add additional items to an already created container. This endpoint can also be used to add items to Open and Distribute containers created through [Open and Distribute 3.0 - Create an Open and Distribute container](developers.usps.com/pmodv3#tag/Resources/operation/post -pmod). determines the level of access and permissions for the API. The value of this parameter should be set to “containers” for containers-related operations. container description here

Parameters:

scope (Scope4) —

Required parameter: The scope of the request, which
container_id (String) —

Required parameter: Container id for the
body (ContaineridPackagesBody) (defaults to: nil) —

Optional parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 801

def post_containers_with_container_id(scope,
                                      container_id,
                                      body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/containers/{container-id}/packages',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(container_id, key: 'container-id')
                                .is_required(true)
                                .should_encode(true))
               .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('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ContainersContainer.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             ContainersErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             ContainersErrorException)
                .local_error('403',
                             'Access is denied.',
                             ContainersErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             ContainersErrorException)
                .local_error('503',
                             'Service is unavailable',
                             ContainersErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_dispute(body) ⇒ `ApiResponse`

Returns a dispute request details. be used for the query.

Parameters:

body (DisputeCreateRequest) —

Required parameter: The parameters to

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4373

def post_dispute(body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/disputes/v3/dispute',
                                 Server::DEFAULT)
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Dispute.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Error response',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException))
    .execute
end

#post_extra_service_rates_search(scope, body: nil) ⇒ `ApiResponse`

Returns eligible extra service prices, descriptions, and SKUs given a set of package rate ingredients. NOTE: The request using an integer (instead of an array) for extraServices is deprecated and will be removed in June 2025. determines the level of access and permissions for the API. The value of this parameter should be set to “prices” for prices-related operations. body Optional parameter: The search parameters to be used for the query.

Parameters:

scope (Scope5) —

Required parameter: The scope of the request, which
(ExtraServiceRateQuery | ExtraServiceRateQueryWithInteger | nil)

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1101

def post_extra_service_rates_search(scope,
                                    body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/extra-service-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .validator(proc do |value|
                              UnionTypeLookUp.get(:PostExtraServiceRatesSearchBody)
                                             .validate(value)
                            end))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(APIHelper.method(:json_serialize))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PricesExtraServiceRateDetail.method(:from_hash))
                .is_api_response(true)
                .is_response_array(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_fast_appointment(scope, body: nil) ⇒ `ApiResponse`

Create Appointment Request provides the ability to create an appointment. determines the level of access and permissions for the API. The value of this parameter should be set to “fast-appointments” for fast-appointments-related operations. corresponding to the supported grant types.

Parameters:

scope (Scope2) —

Required parameter: The scope of the request, which
body (Appointment) (defaults to: nil) —

Optional parameter: The input parameters

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 299

def post_fast_appointment(scope,
                          body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/fast-appointments/appointment',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Appointment.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             FastAppointmentsErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             FastAppointmentsErrorException)
                .local_error('403',
                             'Access is denied.',
                             FastAppointmentsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             FastAppointmentsErrorException)
                .local_error('503',
                             'Service is unavailable',
                             FastAppointmentsErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_get_user_profile(scope) ⇒ `ApiResponse`

```
Authorization: Bearer

```

Parameters:

scope (String) —

Required parameter: TODO: type description here

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7662

def post_get_user_profile(scope)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/userinfo',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ResourceOwnerUserClaims.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  Check the input parameters and values.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized Request.  Check the authentication scheme and'\
                              ' values being used to make the request.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_indicia_imb(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

Generates an Intelligent Mail Barcode (IMB) label for First-Class letters, flats, and cards. [See specification USPS-B-3200](postalpro.usps.com/node/2190). Notes:

Only supported for ‘PAYER’ Roles with an EPS accountType.
When IMB labels are placed on letters, flats, or cards that are larger

than the label itself, the label should be placed in the top right corner in order to avoid delays in processing. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. Authorization Token from the payments API Call. here

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (IndiciaImbRequest) —

Required parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3430

def post_indicia_imb(scope,
                     x_payment_authorization_token,
                     body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/indicia/imb',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(IndiciaImbResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_international_indicia(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

Generates a First-Class Mail International indicia for use on letter, flat, and cards mailings. Note:

First-Class Mail International can be used for mailing correspondence

(no trading cards, bookmarks, stickers, etc.) or nonnegotiable documents (just paper; no cash, checks, or other items with cash value). No customs form is required.

Different countries have different rules on what can be mailed. Look up

your shipping destination in the [Index of Countries and Localities](pe.usps.com/text/Imm/immctry.htm) for specifics on what can and cannot be mailed with First-Class Mail International.

Only supported for ‘PAYER’ Roles with an EPS accountType.
Indicia should be placed in the top right corner of letters, flats, and

cards in order to avoid delays in processing.

An Indicia created using this endpoint is non-refundable.

determines the level of access and permissions for the API. The value of this parameter should be set to “international-labels” for international-labels-related operations. Authorization Token from the payments API Call. Indicia request payload containing necessary data for generating a First-Class Mail International indicia.

Parameters:

scope (Scope8) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (InternationalLabelsIndiciaRequest) —

Required parameter:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2622

def post_international_indicia(scope,
                               x_payment_authorization_token,
                               body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/indicia',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalLabelsIndiciaResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_international_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ `ApiResponse`

Generates a international shipping label based upon the input dimensions requested:

| Element                       | Description |
| ----------------------------- | --------|
| **toAddress**                 | International destination address of

the recipient. Used in pricing as the country. |

| **fromAddress**               | Domestic address where the package is

being mailed from. |

| **senderAddress**             | Domestic address of the business. Can

differ from the ‘fromAddress` in the case the business is using a third-party logistics provider or mailing from off-site locations. |

| **packageDescription**        | Package characteristics used to price

the shipment including requested mail class, weight, dimensions, and more. |

| **imageInfo**                 | Additional details used to update

label characteristics. |

| **customsForm**               | Additional details required for

sending international packages.| The default media type of the response has multiple parts. Setting the Accept header to either application/json or application/xml will only affect the metadata part of the multipart response. **How to use this API** The metadata part of the multipart response representation is only in application/json format media type, as default. The application/xml media type is not supported at this time. Ignore the Content-Encoding header in the second part, the label image file. The contents of this part are not compressed. Ignore the Content-Transfer-Encoding header in the second part, the label image file. The contents of this part are always Base64 encoded. Instructions Extract the first part of the multipart response as application/json media type. Extract the second part of the multipart response and Base64 decode it to yield the binary image file. Save the binary image file, given the Content-Type header value and the filename of this part (e.g. application/pdf, label.pdf). It is recommended that you run a virus scan on the resulting downloaded file. determines the level of access and permissions for the API. The value of this parameter should be set to “international-labels” for international-labels-related operations. Authorization Token from the payments API Call. description here that serves as an idempotency key for safe request retries and duplicate charge prevention during label creation. This value must be a randomly generated UUID and unique per customer (CRID) across all label creation requests. When the same idempotency key is resubmitted with an identical request payload, the API will return the existing label without creating a duplicate or charging additional postage. The UUID will be included in the electronic manifest data (Shipping Services File D5 field) sent to Postal systems.

Parameters:

scope (Scope8) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (InternationalPackageRequest) —

Required parameter: TODO: type
x_idempotency_key (UUID | String) (defaults to: nil) —

Optional parameter: A unique UUID

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2420

def post_international_label(scope,
                             x_payment_authorization_token,
                             body,
                             x_idempotency_key: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/international-label',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter(x_idempotency_key, key: 'X-Idempotency-Key'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalPackageResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ `ApiResponse`

Generates a shipping label based upon the following: | Element | Description | | —————————– | ——–| | toAddress | Address where the package is being shipped to. The ZIP Code™ in the ‘toAddress` object is used to calculate pricing. | | fromAddress | Address where the package is being shipped from. The ZIP Code™ in the `fromAddress` object is used to calculate pricing. | | senderAddress | Address of the business involved. The `senderAddress` can be different from the `fromAddress` when the business address is not where the package is being shipped from. | | returnAddress | Address where the package should be returned to if it is deemed undeliverable or returned to sender. This address will be printed in the return address block of the label. | | packageDescription | Package characteristics used to price the shipment including requested mail class, weight, dimensions, and more. | | imageInfo | Additional details used to determine how to generate the label image. | | customsForm | Additional details required when creating shipments originating from or destinating to MPOs, APOs, FPOs, or DPOs (Military, Army, Fleet, and Diplomatic Post Offices) and some Military and U.S., Possessions, Territories, and Freely Associated States (PTFAS).| The default media type of the response has multiple parts. Setting the Accept header to either application/json or application/xml will only affect the metadata part of the multipart response. **How to use this API** The metadata part of the multipart response representation is only in application/json format media type, as default. The application/xml media type is not supported at this time. Ignore the Content-Encoding header in the second part, the label image file. The contents of this part are not compressed. Ignore the Content-Transfer-Encoding header in the second part, the label image file. The contents of this part are always Base64 encoded. Ignore the Content-Encoding header in the third part, the receipt image file. The contents of this part are not compressed. Ignore the Content-Transfer-Encoding header in the third part, the receipt image file. The contents of this part are always Base64 encoded. Instructions Extract the first part of the multipart response as application/json media type. Extract the second part of the multipart response and Base64 decode it to yield the binary image file. Save the binary image file, given the Content-Type header value and the filename of this part (e.g. application/pdf, label.pdf). It is recommended that you run a virus scan on the resulting downloaded file. Extract the third part of the multipart response and Base64 decode it to yield the binary image file. Save the binary image file, given the Content-Type header value and the filename of this part (e.g. application/pdf, receipt.pdf). It is recommended that you run a virus scan on the resulting downloaded file. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. Authorization Token from the payments API Call. description here that serves as an idempotency key for safe request retries and duplicate charge prevention during label creation. This value must be a randomly generated UUID and unique per customer (CRID) across all label creation requests. When the same idempotency key is resubmitted with an identical request payload, the API will return the existing label without creating a duplicate or charging additional postage. The UUID will be included in the electronic manifest data (Shipping Services File D5 field) sent to Postal systems.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (DomesticPackageRequest) —

Required parameter: TODO: type
x_idempotency_key (UUID | String) (defaults to: nil) —

Optional parameter: A unique UUID

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3051

def post_label(scope,
               x_payment_authorization_token,
               body,
               x_idempotency_key: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/label',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter(x_idempotency_key, key: 'X-Idempotency-Key'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelPackageResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_label_branding(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

The USPS Logo Branding endpoint allows you to upload your custom image or logo to USPS APIs. A UUID is generated for your custom image to leverage for outbound Domestic Labels and Return Labels requests. The user will indicate how their custom image or multiple images will display, and the option to specify the shape of their image when generating labels and return labels. Note:

It may take up to 15 minutes for the label image to propagate to all

regions for label usage.

There is a limit of 100 images to be stored per customer reference ID

(CRID). The CRID will be taken from the ‘LABEL_OWNER` role of your Payment Authorization token.

The root svg element requires a ‘viewbox` attribute
The displayed aspect ratio of images on a label is 1:1 for square images

and 33:5 for rectangle images.

* Recommendation: Allow the artwork inside the viewbox to occupy 100% of

the space. This will allow your logo to be shown at the highest resolution possible.

‘<script/>` element tags and `DOCTYPE` definitions are not allowed. The

‘<use/>` and `<image/>` tags are not allowed to use the attribute `xhref`. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. Authorization Token from the payments API Call. type description here

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (LabelBrandingImageUploadRequest) —

Required parameter: TODO:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3561

def post_label_branding(scope,
                        x_payment_authorization_token,
                        body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/branding',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(LabelBrandingImageUploadResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_label_indicia(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

Generates a First-Class indicia for use on letter, flat, or card mailings. Notes:

Only supported for ‘PAYER’ Roles with an EPS accountType.
Indicia should be placed in the top right corner of letters, flats, and

cards in order to avoid delays in processing.

An Indicia created using this endpoint is non-refundable and cannot be

refunded using the DELETE /indicia/imb endpoint. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. Authorization Token from the payments API Call. payload containing necessary data for generating a First-Class indicia.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (LabelsIndiciaRequest) —

Required parameter: Indicia request

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3370

def post_label_indicia(scope,
                       x_payment_authorization_token,
                       body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/indicia',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalLabelsIndiciaResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_label_reprint(scope, tracking_number, x_payment_authorization_token, body) ⇒ `ApiResponse`

Reprint an international shipping label. Allows for different ‘ImageInfo` options to be specified.

Labels can only be reprinted up to the mailing date.
Labels can only be reprinted up to 3 times.
Canceled labels are not eligible for reprint.

determines the level of access and permissions for the API. The value of this parameter should be set to “international-labels” for international-labels-related operations. number of the label. Authorization Token from the payments API Call. TODO: type description here

Parameters:

scope (Scope8) —

Required parameter: The scope of the request, which
tracking_number (String) —

Required parameter: The unique tracking
x_payment_authorization_token (String) —

Required parameter: Payment
body (InternationalLabelsLabelReprintRequest) —

Required parameter:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2482

def post_label_reprint(scope,
                       tracking_number,
                       x_payment_authorization_token,
                       body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/international-label-reprint/{trackingNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalLabelReprintResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_label_reprint1(scope, tracking_number, x_payment_authorization_token, body) ⇒ `ApiResponse`

Reprint a Domestic Outbound or Domestic Return shipping label. Allows for different ‘ImageInfo` options to be specified.

Receipts cannot be reprinted.
Labels can only be reprinted up to the mailing date.
Labels can only be reprinted up to 3 times.
Canceled labels are not eligible for reprint.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
tracking_number (String) —

Required parameter: The tracking number of
x_payment_authorization_token (String) —

Required parameter: Payment
body (LabelsLabelReprintRequest) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3857

def post_label_reprint1(scope,
                        tracking_number,
                        x_payment_authorization_token,
                        body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/label-reprint/{trackingNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(proc do |response, should_symbolize|
                  APIHelper.deserialize_union_type(
                    UnionTypeLookUp.get(:PostLabelReprint1Response),
                    response, should_symbolize, true
                  )
                end)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_letter_rates_search(scope, body: nil) ⇒ `ApiResponse`

Returns an eligible price given a set of letter rate ingredients for First-Class Mail. determines the level of access and permissions for the API. The value of this parameter should be set to “prices” for prices-related operations. to be used for the query.

Parameters:

scope (Scope5) —

Required parameter: The scope of the request, which
body (LetterRatesQuery) (defaults to: nil) —

Optional parameter: The search parameters

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1264

def post_letter_rates_search(scope,
                             body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/letter-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PricesLetterRatesQueryResult.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_letter_rates_search1(scope, body: nil) ⇒ `ApiResponse`

Returns an eligible price given a set of letter rate ingredients for First-Class Mail International. determines the level of access and permissions for the API. The value of this parameter should be set to “international-prices” for international-prices-related operations. parameters to be used for the query.

Parameters:

scope (Scope9) —

Required parameter: The scope of the request, which
body (InternationalLetterRatesQuery) (defaults to: nil) —

Optional parameter: The search

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2892

def post_letter_rates_search1(scope,
                              body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/letter-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalPricesLetterRatesQueryResult.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_manifest(scope, body: nil) ⇒ `ApiResponse`

Allows the caller to close a container and generate a manifest. determines the level of access and permissions for the API. The value of this parameter should be set to “containers” for containers-related operations.

Parameters:

scope (Scope4) —

Required parameter: The scope of the request, which
body (Manifest) (defaults to: nil) —

Optional parameter: TODO: type description here

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1003

def post_manifest(scope,
                  body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/containers/manifest',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             ContainersErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             ContainersErrorException)
                .local_error('403',
                             'Access is denied.',
                             ContainersErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             ContainersErrorException)
                .local_error('503',
                             'Service is unavailable',
                             ContainersErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_options_search(scope, body) ⇒ `ApiResponse`

Based on the inputs below, the API generates a comprehensive list of shipping options that comply with USPS Shipping Standards, all within a single request. For deliveries with international mail classes, there are no commitments. International delivery may vary based upon origin, destination, and customs delays. For more details, visit [International Mail & Shipping Services](www.usps.com/international/mail-shipping-services.htm). For deliveries with return mail classes, there are no commitments. Return delivery will vary based upon when the return item is entered into the mailstream. For more details, visit [Managing Customer Returns](www.usps.com/business/return-services.htm). APO, DPO, and FPO locations typically do not offer commitments. For more details, visit [Military & Diplomatic Mail](www.usps.com/ship/apo-fpo-dpo.htm).

| Element                          | Description |
| -------------------------------- | --------|
| **originZIPCode**                | The origin ZIP Code&#8482; is where

the package is being mailed from and is used for calculating pricing. |

| **destinationZIPCode**           | The destination ZIP Code&#8482; of

the recipient is used for calculating pricing. |

| **destinationEntryFacilityType** | The Destination Entry Facility Type

the package will be mailed from and is used in calculating Shipping Standards. |

| **packageDescription**           | Package characteristics used to

price the shipment including requested mail class, weight, dimensions, and more. |

| **pricingOptions**               | Pricing options such as price type

and supporting information needed for pricing the shipping option. | determines the level of access and permissions for the API. The value of this parameter should be set to “shipments” for shipments-related operations. Required parameter: TODO: type description here

Parameters:

scope (Scope27) —

Required parameter: The scope of the request, which
body (DomesticOptionsRequest | InternationalOptionsRequest)

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5896

def post_options_search(scope,
                        body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/options/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true)
                            .validator(proc do |value|
                              UnionTypeLookUp.get(:OptionsRequest)
                                             .validate(value)
                            end))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(APIHelper.method(:json_serialize))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(proc do |response, should_symbolize|
                  APIHelper.deserialize_union_type(
                    UnionTypeLookUp.get(:OptionsResponse),
                    response, should_symbolize, true
                  )
                end)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_package_tracking_notifications(tracking_number, scope, body, x_forwarded_for: nil) ⇒ `ApiResponse`

By registering for the USPS® Tracking by Email service, users can receive email notifications about their package tracking events. This service allows customers to submit their email address to be notified of current or future tracking activity. Users can choose to receive notifications for all activity to date, all future activity, or both. Whenever a mail piece receives an email notifiable event, an email with the relevant information will be generated and sent. With the new request type, users can make multiple requests for a single mail piece in a single request. Tracking status can be obtained using just the impb, and if multiple items are found, users can include additional details in the request.

**uniqueTrackingID (MP-Suffix)** - The impb may be reused during the

USPS® retention period. This field uniquely identifies the shipment status of a unique mailpiece when there exists multiple occurrences of the same impb during this retention period. MPSUFFIX value is located in Track/Confirm Fields API response data. Unique to each TrackID.

OR
**approximateIntakeDate (MP-Date)** - When the mailpiece was taken into

USPS® for shipment. The impb may be reused during the USPS® retention period. This field helps to uniquely identify the shipment status of a unique mailpiece when there exists multiple occurrences of the same impb during this retention period. MPDATE value is located in Track/Confirm Fields API response data. Unique to each TrackId. **One email address** is required and user can enter up to three for notifications. *SMS cell phone numbers are not supported at this time.* RequestType at least one is needed and up to 7 within this list [ AL, FD, ED, TD, UP, FS, OA] representation of package barcode data, commonly known as its tracking number. determines the level of access and permissions for the API. The value of this parameter should be set to “tracking” for tracking-related operations. information to send notifications to. address of the originating client, in additon to intermediate proxies that have forwarded the request. If a request goes through multiple proxies, the IP addresses of each successive proxy is listed. This means, the right-most IP address is the IP address of the most recent proxy and the left-most IP address is the IP address of the originating client.

Parameters:

tracking_number (String) —

Required parameter: The human-readable
scope (Scope18) —

Required parameter: The scope of the request, which
body (TrackingNotificationRequest) —

Required parameter: Contact
x_forwarded_for (String) (defaults to: nil) —

Optional parameter: Contains the IP

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4969

def post_package_tracking_notifications(tracking_number,
                                        scope,
                                        body,
                                        x_forwarded_for: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/tracking/{trackingNumber}/notifications',
                                 Server::DEFAULT)
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter(x_forwarded_for, key: 'X-Forwarded-For'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(TrackingNotificationAcknowledgment.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('404',
                             'Package with tracking number not found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too many requests have been received from the client in a'\
                              ' short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#post_payments_payment_authorization(scope, body: nil) ⇒ `ApiResponse`

Create a payment authorization token that can be subsequently used for purchasing labels. Tokens are valid for eight hours after issuance. The roles input is required to generate this token. The roles object should contain information for each role for the transaction in which this token will be used. The ‘PAYER` and `LABEL_OWNER` roles are required to pay for any label transaction. The available roles are:

PAYER - This role is used to specify who will pay for the

transaction. When using the ‘PAYER` role, the `accountType` and `CRID` must be specified. If the `accountType` is `EPS`, the `accountNumber` must be active in the Enterprise Payment System (EPS).

RATE_HOLDER - This role is used to specify whose rates will be used

in the transaction and will be used to lookup any contract-specific service standards. When using the ‘RATE_HOLDER` role, the `accountType` and `CRID` must be specified.

LABEL_OWNER - This role is used to specify whose label ranges will

be used in the transaction. When using the ‘LABEL_OWNER` role, the `CRID`, `MID` and `manifestMID` must be specified. The `MID` and `CRID` must be enrolled in USPS Ship Outbound or Returns.

SHIPPER - This role is used to specify who is entering the packages

into the mailstream. When using ‘SHIPPER` role, the `CRID` must be specified.

MAIL_OWNER - This role is used to specify who owns the package

contents. When using the ‘MAIL_OWNER` role, the `CRID` must be specified. This does not populate the mail owner field in the D1 record of the Shipping Service File (SSF). Please use the `packageDescription.mailOwnerMID` field in the Label Request to populate the D1 field.

PLATFORM - This role is used to specify the platform used to make

the API calls. When using the ‘PLATFORM` role, the `CRID` must be specified.

RETURN_LABEL_PAYER - This role is used to specify who will pay for

the return label transaction. Optional if outbound and return label payer are the same. When using the ‘RETURN_LABEL_PAYER` role, the `accountType` and `CRID` must be specified. If the `accountType` is `EPS`, the `accountNumber` must be active in the Enterprise Payment System (EPS).

RETURN_LABEL_RATE_HOLDER - This role is used to specify the owner of

the Contracted Postage Rates for the return label in a combined outbound/return request. Optional if outbound and return label rate holder are the same. When using the ‘RETURN_LABEL_RATE_HOLDER` role, the `accountType` and `CRID` must be specified.

RETURN_LABEL_OWNER - This role is used to specify whose label ranges

will be used in the return label in a combined outbound/return request. Optional if outbound and return label owner are the same. When using the RETURN_LABEL_OWNER role, the ‘CRID`, `MID` and `manifestMID` must be specified. The `MID` and `CRID` must be enrolled in USPS Ship Returns.

LABEL_PROVIDER - This role is used to specify the label provider for

the transaction. When using the ‘LABEL_PROVIDER` role, the `CRID`, `accountNumber`, and `accountType` must be specified and the only supported accountType is `EPS`. The `accountNumber` must be active in the Enterprise Payment System (EPS). determines the level of access and permissions for the API. The value of this parameter should be set to “payments” for payments-related operations. TODO: type description here

Parameters:

scope (Scope19) —

Required parameter: The scope of the request, which
body (InterestedPartiesIdentityInformation) (defaults to: nil) —

Optional parameter:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5146

def post_payments_payment_authorization(scope,
                                        body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/payment-authorization',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InterestedPartiesIdentityInformation.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_pmod(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

Create a new Open and Distribute container with the associated attributes from the request body. Packages can be added to the container until manifest using [Domestic Labels 3.0 - Create a Domestic Shipping Label](developers.usps.com/domesticlabelsv3) or [Containers 3.0 - Add Packages or Mail to a Container Manifest](developers.usps.com/containersv3). Packages can be removed from the container using [Containers 3.0 - Remove All Packages from a Container](developers.usps.com/containersv3) or [Containers 3.0 - Remove Individual Packages from a Container](developers.usps.com/containersv3). The response will contain the IMpb label and a 99M IMcb label. determines the level of access and permissions for the API. The value of this parameter should be set to “pmod” for pmod-related operations. Authorization Token from the payments API Call. description here

Parameters:

scope (Scope17) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (CreateOdContainerRequest) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4719

def post_pmod(scope,
              x_payment_authorization_token,
              body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/pmod/create',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CreateOdContainerResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PmodErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PmodErrorException)
                .local_error('403',
                             'Access is denied.',
                             PmodErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PmodErrorException)
                .local_error('503',
                             'Service is unavailable',
                             PmodErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_qrcode_search(scope, body: nil) ⇒ `ApiResponse`

The QR Code API enables shippers and integrators to request and receive QR codes for packages addressed to USPS lockers upon delivery. This empowers shippers to manage their customers’ post-purchase experience by sharing package pickup instructions directly with their customers. Access to the QR Code API is restricted to tracking numbers associated with mailer IDs (MIDs) owned by the integrator or shipper. The API response returns a base64-encoded QR code image, which must be converted into an image before use. determines the level of access and permissions for the API. The value of this parameter should be set to “qr-code” for qr-code-related operations. here

Parameters:

scope (Scope20) —

Required parameter: The scope of the request, which
body (QrCodeRequest) (defaults to: nil) —

Optional parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5270

def post_qrcode_search(scope,
                       body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(proc do |response, should_symbolize|
                  APIHelper.deserialize_union_type(
                    UnionTypeLookUp.get(:PostQrcodeSearchResponse),
                    response, should_symbolize, true
                  )
                end)
                .is_api_response(true)
                .local_error('400',
                             'Bad request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied',
                             AddressesErrorException)
                .local_error('404',
                             'No record found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_rate_list(scope, body: nil) ⇒ `ApiResponse`

Returns a list of eligible prices given dimensions/weight/destination of pieces. Search for contract prices; either by:

Enterprise Payment System (EPS) account
Meter number
Permit number

A specific mail class is required when searching for contract prices. determines the level of access and permissions for the API. The value of this parameter should be set to “prices” for prices-related operations. be used for the query.

Parameters:

scope (Scope5) —

Required parameter: The scope of the request, which
body (RateListQuery) (defaults to: nil) —

Optional parameter: The search parameters to

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1162

def post_rate_list(scope,
                   body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/base-rates-list/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(BaseRateDetails.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_return_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ `ApiResponse`

Generates a returns shipping label based upon the input dimensions requested. | Element | Description | | —————————— | ——– | | toAddress | Address where the return package is being shipped to. The ZIP Code™ in the ‘toAddress` object is used to calculate pricing. | | fromAddress | Address where the return package is being shipped from. The ZIP Code™ in the `fromAddress` object is used to calculate pricing. | | senderAddress | Address of the business involved (typically the sender of the original package). The `senderAddress` can be different from the `toAddress` when the business address is not where the package is being shipped to. | | returnAddress | Address where the package should be returned to if it is deemed undeliverable or returned to sender. This address will be printed in the return address block of the label. This could be a secondary return address in case the `toAddress` is deemed undeliverable or returned to sender. | | packageDescription | Package characteristics used to price the shipment including requested mail class, weight, dimensions, and more. | | imageInfo | Additional details used to update label characteristics | | customsForm | Additional details required when creating shipments originating from or destinating to MPOs, APOs, FPOs, or DPOs (Military, Army, Fleet, and Diplomatic Post Offices) and some Military and U.S. Possessions, Territories, and Freely Associated States (PTFAS).| The default media type of the response has multiple parts. Setting the Accept header to either `application/json` or `application/xml` will only affect the metadata part of the multipart response. **How to use this API** The metadata part of the multipart response representation is only in application/json format media type, as default. Ignore the Content-Encoding header in the second part, the label image file. The contents of this part are not compressed. Ignore the Content-Transfer-Encoding header in the second part, the label image file. The contents of this part are always Base64 encoded. Ignore the Content-Encoding header in the third part, the receipt image file. The contents of this part are not compressed. Ignore the Content-Transfer-Encoding header in the third part, the receipt image file. The contents of this part are always Base64 encoded. Instructions Extract the first part of the multipart response as application/json media type. Extract the second part of the multipart response and Base64 decode it to yield the binary image file. Save the binary image file, given the Content-Type header value and the filename of this part (e.g. application/pdf, label.pdf). It is recommended that you run a virus scan on the resulting downloaded file. Extract the third part of the multipart response and Base64 decode it to yield the binary image file. Save the binary image file, given the Content-Type header value and the filename of this part (e.g. application/pdf, receipt.pdf). It is recommended that you run a virus scan on the resulting downloaded file. determines the level of access and permissions for the API. The value of this parameter should be set to “labels” for labels-related operations. Authorization Token from the payments API Call. description here that serves as an idempotency key for safe request retries and duplicate charge prevention during label creation. This value must be a randomly generated UUID and unique per customer (CRID) across all label creation requests. When the same idempotency key is resubmitted with an identical request payload, the API will return the existing label without creating a duplicate or charging additional postage. The UUID will be included in the electronic manifest data (Shipping Services File D5 field) sent to Postal systems.

Parameters:

scope (Scope11) —

Required parameter: The scope of the request, which
x_payment_authorization_token (String) —

Required parameter: Payment
body (ReturnsPackageRequest) —

Required parameter: TODO: type
x_idempotency_key (UUID | String) (defaults to: nil) —

Optional parameter: A unique UUID

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 3172

def post_return_label(scope,
                      x_payment_authorization_token,
                      body,
                      x_idempotency_key: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/return-label',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(x_payment_authorization_token, key: 'X-Payment-Authorization-Token')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter(x_idempotency_key, key: 'X-Idempotency-Key'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ReturnLabelPackageResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' the client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_return_service_standards_directory(scope, body) ⇒ `ApiResponse`

**Request Directory of Service Standards**: Return service standard data. Origin/Destination ZIP codes can be 3-digit or 5-digit. determines the level of access and permissions for the API. The value of this parameter should be set to “service-standards-directory” for service-standards-directory-related operations. here

Parameters:

scope (Scope24) —

Required parameter: The scope of the request, which
body (V3ReporterRequest) —

Required parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5781

def post_return_service_standards_directory(scope,
                                            body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/reporter',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ServiceStandardsResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request. There is an error in the received request.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource not found.',
                             AddressesErrorException)
                .local_error('500',
                             'Internal server error.',
                             AddressesErrorException))
    .execute
end

#post_revoke(scope, token, token_type_hint: TokenTypeHint::REFRESH_TOKEN) ⇒ `ApiResponse`

Prevent tokens from being further used to access APIs by invalidating OAuth tokens which are no longer needed. This resource is based on the 'OAuth 2.0 Token Revocation', IETF Draft RFC 7009, August 2013, see [OAuth 2.0 Token Revocation](datatracker.ietf.org/doc/html/rfc7009). Basic Authentication is used to access this resource, using the issued client Id and client secret.

“‘ Authorization: Basic N0MyejJiS1FodDJUTEJjVTE2VmxlZUplQm1hdExiMjQ6TENtSE85RUFENXk0bUNURA== “` Only refresh tokens may be revoked, since access tokens are self-contained, and formatted using JSON Web Token industry standard. determines the level of access and permissions for the API. The value of this parameter should be set to “oauth2” for oauth2-related operations. type of the given token. See OAuth Token Types Hint registry, www.rfc-editor.org/rfc/rfc7009#section-4.1.2.1

Parameters:

scope (Scope16) —

Required parameter: The scope of the request, which
token (String) —

Required parameter: The token (a hash value).
token_type_hint (TokenTypeHint) (defaults to: TokenTypeHint::REFRESH_TOKEN) —

Optional parameter: A hint to the

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4536

def post_revoke(scope,
                token,
                token_type_hint: TokenTypeHint::REFRESH_TOKEN)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/revoke',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .form_param(new_parameter(token, key: 'token')
                            .is_required(true))
               .form_param(new_parameter(token_type_hint, key: 'token_type_hint'))
               .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
               .auth(Single.new('BasicAuth')))
    .response(new_response_handler
                .is_response_void(true)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  Check the input parameters and values.',
                             OauthStandardErrorResponseException)
                .local_error('401',
                             'Unauthorized Request.  Check the authentication scheme and'\
                              ' values being used to make the request.',
                             OauthStandardErrorResponseException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             OauthStandardErrorResponseException)
                .local_error('503',
                             'Service Unavailable.',
                             OauthStandardErrorResponseException))
    .execute
end

#post_scan_form(scope, body) ⇒ `ApiResponse`

The default media type of the response is multipart-mixed. Setting the Accept header to either application/json or application/xml will only affect the metadata part of the multipart response. **How to use this API**

The metadata part of the multipart response representation is only in

application/json format media type, as default. The application/xml media type is not supported at this time.

Ignore the Content-Encoding header in the second part, the SCAN form

image file. The contents of this part are not compressed.

Ignore the Content-Transfer-Encoding header in the second part, the SCAN

form image file. The contents of this part are always Base64 encoded.

Instructions

Extract the first part of the multipart response as application/json

media type.

Extract the second part of the multipart response and Base64 decode it

to yield the binary image file.

Save the binary image file, given the Content-Type header value and the

filename of this part (e.g. application/pdf, SCANForm.pdf).

It is recommended that you run a virus scan on the resulting downloaded

file.

determines the level of access and permissions for the API. The value of this parameter should be set to “scan-forms” for scan-forms-related operations. description here

Parameters:

scope (Scope22) —

Required parameter: The scope of the request, which
body (ScanFormsScanForm1) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5440

def post_scan_form(scope,
                   body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/scan-form',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ScanFormsScanForm.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_shipments_tracking(scope, body) ⇒ `ApiResponse`

Submits a real-time tracking event for a shipment in transit. Each event captures the trailer’s current GPS coordinates and event milestone, and links the customer’s external load number to the USPS FAST Appointment ID — providing unified visibility for both drivers and customers. | Element | Description | | ——- | ———– | | externalLoadNumber | The caller’s internal load identifier. Associates the customer’s shipment reference with the USPS appointment, giving drivers and customers a shared reference across systems. | | appointmentID | The FAST-assigned appointment ID that this tracking event is associated with. | | appointmentDate | The scheduled date and time (ISO 8601) of the USPS dock appointment. | | trailerID | Unique identifier for the physical trailer carrying the shipment. | | schedulerCRID | The CRID of the scheduler submitting the tracking event. | | ETA | Estimated time of arrival at the current destination. Required for all event types except ‘FACILITY_ARRIVE` and `FACILITY_DEPART`. | | ETAStatus | Status of the ETA relative to the current stop (not the appointment). Required for all event types except `FACILITY_ARRIVE` and `FACILITY_DEPART`. | | location | The destination stop details including location type, stop type, stop sequence, and either a `dropSiteKey` (USPS) or `ZIPCode5` (CUSTOMER / NON_USPS). | | currentLocation | The real-time GPS coordinates (latitude/longitude) and timestamp of the trailer’s current position. | | currentEvent | The milestone event type being reported for this update. | | positionalInfo | Telemetry data including ping interval, distance traveled, speed, and GPS accuracy. | | resourceInfo | Optional metadata about who submitted the event, device permission states, and comments. | **Location Type Rules** The required identifier for the ‘location` object depends on `locationType`: | locationType | Required Field | | ———— | ————– | | `USPS` | `dropSiteKey` | | `CUSTOMER` | `ZIPCode5` | | `NON_USPS` | `ZIPCode5` | **Event Types** Use `currentEvent.eventType` to report the current milestone in the shipment’s journey. Choose the event type that best reflects the trailer’s actual status at the time of submission. | eventType | When to Use | ETA Required | ETAStatus Required | | ——— | ———– | ———— | —————— | | ‘EN_ROUTE` | The trailer has departed its origin or a prior stop and is actively traveling toward the next destination. Use this as the standard in-transit event to report periodic location updates during movement. | Yes | Yes | | `PRE_ARRIVAL` | The trailer is approaching the next stop and is within a defined proximity or time threshold. Use this event to give the receiving facility advance notice before physical arrival so staff can prepare for the appointment. | Yes | Yes | | `FACILITY_ARRIVE` | The trailer has physically arrived at the scheduled stop (USPS facility, customer, or non-USPS location). Submit this event when the trailer checks in or is confirmed on-site. `ETA` and `ETAStatus` are not required because arrival is the status. | No | No | | `FACILITY_DEPART` | The trailer has completed its activity at a stop and has physically departed. Submit this event when the trailer leaves the facility or customer location and before the next `EN_ROUTE` update begins. `ETA` and `ETAStatus` are not required because departure itself is the status. | No | No | Instructions

Obtain a valid OAuth 2.0 bearer token with the ‘logistics` scope before

making requests.

Populate ‘externalLoadNumber` with your internal load reference and

‘appointmentID` with the USPS FAST appointment ID to link the two systems.

Set ‘location.locationType` to `USPS`, `CUSTOMER`, or `NON_USPS` to the

desired destination and include the corresponding required identifier (‘dropSiteKey` or `ZIPCode5`).

Set ‘currentEvent.eventType` to the appropriate milestone. For

‘FACILITY_ARRIVE` and `FACILITY_DEPART`, omit `ETA` and `ETAStatus`.

For all other event types, include ‘ETA` (ISO 8601 date-time) and a

valid ‘ETAStatus` value: `ON_TIME`, `EARLY`, `DELAYED`, `LATE`, `CANCELLED`, `REDIRECTED`, or `RESCHEDULED`.

Provide accurate GPS coordinates in ‘currentLocation` at each ping. The

‘positionalInfo.pingInterval` controls how frequently updates are sent (in milliseconds).

Optionally include ‘resourceInfo` to record whether the submission was

‘MANUAL` or `AUTOMATIC`, submitted by a `CUSTOMER` or `DRIVER`, and any relevant comments. determines the level of access and permissions for the API. The value of this parameter should be set to “logistics” for logistics-related operations. event to create

Parameters:

scope (Scope13) —

Required parameter: The scope of the request, which
body (ShipmentTrackingEvent) —

Required parameter: Shipment tracking

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4332

def post_shipments_tracking(scope,
                            body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/shipment-tracking',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ShipmentTrackingEvent.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad request',
                             LogisticsErrorException)
                .local_error('401',
                             'Unauthorized',
                             LogisticsErrorException)
                .local_error('403',
                             'Forbidden',
                             LogisticsErrorException)
                .local_error('429',
                             'Too Many Requests',
                             LogisticsErrorException)
                .local_error('503',
                             'Service unavailable',
                             LogisticsErrorException))
    .execute
end

#post_subscriptions_adjustment(scope, body) ⇒ `ApiResponse`

Create a Subscription to Adjustment Events Topic. A subscription can be created for a Customer Registration ID and you can specify what type of adjustment events you want to receive. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-adjustments” for subscriptions-adjustments-related operations. input parameters corresponding to the supported grant types.

Parameters:

scope (Scope28) —

Required parameter: The scope of the request, which
body (SubscriptionsAdjustmentsSubscription) —

Required parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6009

def post_subscriptions_adjustment(scope,
                                  body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsAdjustmentsSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_subscriptions_dispute(scope, body) ⇒ `ApiResponse`

Create a Subscription to Disputes Events Topic. A subscription can be created for a Customer Registration ID and you can specify what type of dispute events you want to receive. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-disputes” for subscriptions-disputes-related operations. input parameters corresponding to the supported grant types.

Parameters:

scope (Scope29) —

Required parameter: The scope of the request, which
body (SubscriptionsDisputesSubscription) —

Required parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6280

def post_subscriptions_dispute(scope,
                               body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsDisputesSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_subscriptions_ncoa(scope, body) ⇒ `ApiResponse`

Create a Subscription to be alerted for Change of Address for specfied the address. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-ncoa” for subscriptions-ncoa-related operations. parameters corresponding to the supported grant types.

Parameters:

scope (Scope30) —

Required parameter: The scope of the request, which
body (SubscriptionsNcoaSubscription) —

Required parameter: The input

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6549

def post_subscriptions_ncoa(scope,
                            body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsNcoaSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid request information.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_subscriptions_package_transaction_details(scope, body) ⇒ `ApiResponse`

Create a Subscription to Package Transaction Details Events Topic. A subscription can be created for a Customer Registration ID. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-package-transaction-details” for subscriptions-package-transaction-details-related operations. parameter: The input parameters corresponding to the supported grant types.

Parameters:

scope (Scope31) —

Required parameter: The scope of the request, which
body (SubscriptionsPackageTransactionDetailsSubscription) —

Required

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6823

def post_subscriptions_package_transaction_details(scope,
                                                   body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsPackageTransactionDetailsSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_subscriptions_tracking(scope, body) ⇒ `ApiResponse`

Create a Subscription to Tracking Events Topic. A subscription can be created for a mailer id or a tracking number. You also can specify what type of tracking events you want to receive. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-tracking” for subscriptions-tracking-related operations. input parameters corresponding to the supported grant types.

Parameters:

scope (Scope32) —

Required parameter: The scope of the request, which
body (SubscriptionsTrackingSubscription) —

Required parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7102

def post_subscriptions_tracking(scope,
                                body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsTrackingSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid request information.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Access Denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_subscriptions_unpaid_subscriptions(scope, body) ⇒ `ApiResponse`

Create a Subscription to Unpaid Packages Events Topic. A subscription can be created for a Customer Registration ID and you can specify what type of Unpaid Packages events you want to receive. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-unpaid-packages” for subscriptions-unpaid-packages-related operations. The input parameters corresponding to the supported grant types.

Parameters:

scope (Scope33) —

Required parameter: The scope of the request, which
body (SubscriptionsUnpaidPackagesSubscription) —

Required parameter:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7374

def post_subscriptions_unpaid_subscriptions(scope,
                                            body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/subscriptions',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsUnpaidPackagesSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Invalid request information',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_token(scope, body: nil) ⇒ `ApiResponse`

Issue one or more OAuth tokens for a client application to use to make subsequent resource requests. Based on the _OAuth 2.0 Authorization Framework_, IETF Draft RFC 6749, October 2012, see [The OAuth 2.0 Authorization Framework](datatracker.ietf.org/doc/html/rfc6749). The expires_in and refresh_token_expires_in fields in the token response specify the respective valid lifetimes for each token. The following OAuth grant types are supported:

**Client Credentials Grant**, see [IETF 6749, section

4.4](datatracker.ietf.org/doc/html/rfc6749#section-4.4).

**Refresh Token**, see [IETF 6749, section

6](datatracker.ietf.org/doc/html/rfc6749#section-6)

**Authorization Code Grant**, see [IETF 6749, section

4.1](datatracker.ietf.org/doc/html/rfc6749#section-4.1). determines the level of access and permissions for the API. The value of this parameter should be set to “oauth2” for oauth2-related operations. AuthorizationCodeCredentialsTokenRequest | nil] body Optional parameter: The input parameters corresponding to the supported grant types.

Parameters:

scope (Scope16) —

Required parameter: The scope of the request, which
ClientCredentialsTokenRequest (ClientCredentialsTokenRequest | RefreshTokenCredentialsRequest |) —

| RefreshTokenCredentialsRequest |

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 4472

def post_token(scope,
               body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/token',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .validator(proc do |value|
                              UnionTypeLookUp.get(:PostTokenBody)
                                             .validate(value)
                            end))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(APIHelper.method(:json_serialize)))
    .response(new_response_handler
                .deserializer(proc do |response, should_symbolize|
                  APIHelper.deserialize_union_type(
                    UnionTypeLookUp.get(:PostTokenResponse),
                    response, should_symbolize, true
                  )
                end)
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  Check the input parameters and values.',
                             OauthStandardErrorResponseException)
                .local_error('401',
                             'Unauthorized Request.  Check the authentication scheme and'\
                              ' values being used to make the request.',
                             OauthStandardErrorResponseException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             OauthStandardErrorResponseException)
                .local_error('503',
                             'Service Unavailable.',
                             OauthStandardErrorResponseException))
    .execute
end

#post_total_rates_search(scope, body: nil) ⇒ `ApiResponse`

This API returns a list of eligible prices, including extra service fees, given the dimensions, weight, origin and destination of your package. determines the level of access and permissions for the API. The value of this parameter should be set to “prices” for prices-related operations. parameters to be used for the query.

Parameters:

scope (Scope5) —

Required parameter: The scope of the request, which
body (PricesTotalRatesQuery) (defaults to: nil) —

Optional parameter: The search

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1213

def post_total_rates_search(scope,
                            body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/total-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PricesTotalRateDetails.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_total_rates_search1(scope, body: nil) ⇒ `ApiResponse`

Performs a search for base price and extraServices using the submitted rate ingredients. If itemValue is not included the response will not include insurance, registered mail, and collect on delivery extra services. If the extraService array is not specified then all eligible extra services will be included. determines the level of access and permissions for the API. The value of this parameter should be set to “international-prices” for international-prices-related operations. search parameters to be used for the query.

Parameters:

scope (Scope9) —

Required parameter: The scope of the request, which
body (InternationalPricesTotalRatesQuery) (defaults to: nil) —

Optional parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2840

def post_total_rates_search1(scope,
                             body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/total-rates/search',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(InternationalPricesTotalRateDetails.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             AddressesErrorException)
                .local_error('403',
                             'Access is denied.',
                             AddressesErrorException)
                .local_error('404',
                             'Resource Not Found',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service is unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#post_tracking_number_campaigns(scope, crid, campaign_id, body) ⇒ `ApiResponse`

Add tracking numbers to an Informed Delivery package campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-package-campaigns” for informed-delivery-package-campaigns-related operations. Customer Registration ID (CRID). campaign. description here

Parameters:

scope (Scope7) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The Package campaign submitter’s
campaign_id (String) —

Required parameter: Unique identifier for the
body (TrackingNumberRequest) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2332

def post_tracking_number_campaigns(scope,
                                   crid,
                                   campaign_id,
                                   body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}/pieces',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(TrackingNumberSuccessResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             APIException))
    .execute
end

#proof_of_delivery(tracking_number, scope, body, x_forwarded_for: nil) ⇒ `ApiResponse`

Proof of Delivery is a letter that includes the recipient’s name and a copy of their signature. The Proof of Delivery API allows the customer to request proof of delivery notification via email. representation of package barcode data, commonly known as its tracking number. determines the level of access and permissions for the API. The value of this parameter should be set to “tracking” for tracking-related operations. information required for returning the proof of delivery to the recipient. address of the originating client, in additon to intermediate proxies that have forwarded the request. If a request goes through multiple proxies, the IP addresses of each successive proxy is listed. This means, the right-most IP address is the IP address of the most recent proxy and the left-most IP address is the IP address of the originating client.

Parameters:

tracking_number (String) —

Required parameter: The human-readble
scope (Scope18) —

Required parameter: The scope of the request, which
body (ProofOfDeliveryRequest) —

Required parameter: Additional
x_forwarded_for (String) (defaults to: nil) —

Optional parameter: Contains the IP

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 5039

def proof_of_delivery(tracking_number,
                      scope,
                      body,
                      x_forwarded_for: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/{scope}/v3/tracking/{trackingNumber}/proof-of-delivery',
                                 Server::DEFAULT)
               .template_param(new_parameter(tracking_number, key: 'trackingNumber')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter(x_forwarded_for, key: 'X-Forwarded-For'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(ProofOfDeliveryResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('404',
                             'Package with tracking number not found.',
                             AddressesErrorException)
                .local_error('429',
                             'Too many requests have been received from the client in a'\
                              ' short amount of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'An unknown error has occurred.',
                             APIException))
    .execute
end

#put_campaigns(scope, crid, campaign_id, body) ⇒ `ApiResponse`

Edit a previously existing Informed Delivery campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). campaign here

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
campaign_id (String) —

Required parameter: ID of Informed Delivery
body (CampaignEdit) —

Required parameter: TODO: type description

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1765

def put_campaigns(scope,
                  crid,
                  campaign_id,
                  body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(CampaignEditResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsErrorException))
    .execute
end

#put_carrier_pickup_confirmation_number(scope, confirmation_number, if_match, body) ⇒ `ApiResponse`

Update information contained in a previously scheduled carrier pickup such as the pickup date, the types and counts of packages for the carrier to pick up, the weight or the pickup location. determines the level of access and permissions for the API. The value of this parameter should be set to “pickup” for pickup-related operations. Carrier Pickup confirmation number. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. description here

Parameters:

scope (Scope3) —

Required parameter: The scope of the request, which
confirmation_number (String) —

Required parameter: This is the
if_match (String) —

Required parameter: The value of the entity tag
body (PickupConfirmation) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 683

def put_carrier_pickup_confirmation_number(scope,
                                           confirmation_number,
                                           if_match,
                                           body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/carrier-pickup/{confirmationNumber}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(confirmation_number, key: 'confirmationNumber')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(PickupConfirmation.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             PickupErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             PickupErrorException)
                .local_error('403',
                             'Access is denied.',
                             PickupErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             PickupErrorException)
                .local_error('503',
                             'Service is unavailable.',
                             PickupErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_fast_appointment(scope, body: nil) ⇒ `ApiResponse`

Update Appointment Request provides the ability to update an appointment. determines the level of access and permissions for the API. The value of this parameter should be set to “fast-appointments” for fast-appointments-related operations. corresponding to the supported grant types.

Parameters:

scope (Scope2) —

Required parameter: The scope of the request, which
body (Appointment) (defaults to: nil) —

Optional parameter: The input parameters

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 347

def put_fast_appointment(scope,
                         body: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/fast-appointments/appointment',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .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(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(Appointment.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.  There is an error in the received request.',
                             FastAppointmentsErrorException)
                .local_error('401',
                             'Unauthorized request.',
                             FastAppointmentsErrorException)
                .local_error('403',
                             'Access is denied.',
                             FastAppointmentsErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amount of time.',
                             FastAppointmentsErrorException)
                .local_error('503',
                             'Service is unavailable',
                             FastAppointmentsErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_package_campaigns(scope, crid, campaign_id, body) ⇒ `ApiResponse`

Edit a previously existing Informed Delivery package campaign determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-package-campaigns” for informed-delivery-package-campaigns-related operations. Customer Registration ID (CRID). campaign. description here

Parameters:

scope (Scope7) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The Package campaign submitter’s
campaign_id (String) —

Required parameter: Unique identifier for the
body (EditPackageCampaign) —

Required parameter: TODO: type

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 2249

def put_package_campaigns(scope,
                          crid,
                          campaign_id,
                          body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/campaigns/{CRID}/{campaignID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(campaign_id, key: 'campaignID')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(EditPackageCampaignResponse.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryPackageCampaignsErrorException))
    .execute
end

#put_subscriptions_adjustment_id(scope, subscription_id, if_match, body) ⇒ `ApiResponse`

Use this endpoint to update the callback url, secret, or status. If filter properties need to change, a new subscription needs to be created. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-adjustments” for subscriptions-adjustments-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. input parameters corresponding to the supported grant types.

Parameters:

scope (Scope28) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag
body (SubscriptionsAdjustmentsSubscription) —

Required parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6114

def put_subscriptions_adjustment_id(scope,
                                    subscription_id,
                                    if_match,
                                    body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsAdjustmentsSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_subscriptions_dispute_id(scope, subscription_id, if_match, body) ⇒ `ApiResponse`

Use this endpoint to update the callback url, secret, or status. If filter properties need to change, a new subscription needs to be created. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-disputes” for subscriptions-disputes-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. input parameters corresponding to the supported grant types.

Parameters:

scope (Scope29) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag
body (SubscriptionsDisputesSubscription) —

Required parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6385

def put_subscriptions_dispute_id(scope,
                                 subscription_id,
                                 if_match,
                                 body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsDisputesSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_subscriptions_ncoa_id(scope, subscription_id, if_match, body) ⇒ `ApiResponse`

Use this endpoint to update the callback url, secret, or status. If filter properties need to change, a new subscription needs to be created. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-ncoa” for subscriptions-ncoa-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. parameters corresponding to the supported grant types.

Parameters:

scope (Scope30) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag
body (SubscriptionsNcoaSubscription) —

Required parameter: The input

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6654

def put_subscriptions_ncoa_id(scope,
                              subscription_id,
                              if_match,
                              body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsNcoaSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_subscriptions_package_transaction_details_id(scope, subscription_id, if_match, body) ⇒ `ApiResponse`

Use this endpoint to update the callback url, secret, or status. If filter properties need to change, a new subscription needs to be created. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-package-transaction-details” for subscriptions-package-transaction-details-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. parameter: The input parameters corresponding to the supported grant types.

Parameters:

scope (Scope31) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag
body (SubscriptionsPackageTransactionDetailsSubscription) —

Required

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 6931

def put_subscriptions_package_transaction_details_id(scope,
                                                     subscription_id,
                                                     if_match,
                                                     body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsPackageTransactionDetailsSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_subscriptions_tracking_id(scope, subscription_id, if_match, body) ⇒ `ApiResponse`

Use this endpoint to update the callback url, secret, or status. If filter properties need to change, a new subscription needs to be created. determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-tracking” for subscriptions-tracking-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. input parameters corresponding to the supported grant types.

Parameters:

scope (Scope32) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag
body (SubscriptionsTrackingSubscription) —

Required parameter: The

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7207

def put_subscriptions_tracking_id(scope,
                                  subscription_id,
                                  if_match,
                                  body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsTrackingSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request.',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized.',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden.',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable.',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#put_subscriptions_unpaid_packages_id(scope, subscription_id, if_match, body) ⇒ `ApiResponse`

“Use this endpoint to update the callback URL, secret, or status. If filter properties need to change, a new subscription needs to be created.” determines the level of access and permissions for the API. The value of this parameter should be set to “subscriptions-unpaid-packages” for subscriptions-unpaid-packages-related operations. of the subscription. indicating the version of the resource to get or update. All DELETE and PUT operations require an ETag to be supplied as the If-Match parameter. The ETag is returned in the GET operation and is good for one hour or until it is used in a DELETE or PUT operation. The input parameters corresponding to the supported grant types.

Parameters:

scope (Scope33) —

Required parameter: The scope of the request, which
subscription_id (String) —

Required parameter: The unique identifier
if_match (String) —

Required parameter: The value of the entity tag
body (SubscriptionsUnpaidPackagesSubscription) —

Required parameter:

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 7479

def put_subscriptions_unpaid_packages_id(scope,
                                         subscription_id,
                                         if_match,
                                         body)
  @api_call
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/{scope}/v3/subscriptions/{subscriptionId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(subscription_id, key: 'subscriptionId')
                                .is_required(true)
                                .should_encode(true))
               .header_param(new_parameter(if_match, key: 'If-Match')
                              .is_required(true))
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body)
                            .is_required(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Or.new('OAuth_authorization_code', 'OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(SubscriptionsUnpaidPackagesSubscription.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             AddressesErrorException)
                .local_error('401',
                             'Unauthorized',
                             AddressesErrorException)
                .local_error('403',
                             'Forbidden',
                             AddressesErrorException)
                .local_error('429',
                             'Too Many Requests. Too many requests have been received from'\
                              ' client in  a short amout of time.',
                             AddressesErrorException)
                .local_error('503',
                             'Service Unavailable',
                             AddressesErrorException)
                .local_error('default',
                             'Other unanticipated errors that may occur.',
                             APIException))
    .execute
end

#query_mail_campaigns(scope, crid, offset: 0, limit: 100, sort: nil, ezsearch: nil, barcode_count: nil, brand_display_name: nil, campaign_code: nil, mid: nil, mailpiece_shape: nil, campaign_title: nil, campaign_type: nil, created_datetime: nil, campaign_source: nil, end_date: nil, end_serial: nil, last_modified_datetime: nil, last_modified_source: nil, last_modified_username: nil, mail_owner_crid: nil, mail_owner_name: nil, postal_one_saturation_job_id: nil, is_shareable: nil, start_date: nil, start_serial: nil, status: nil, submitted_datetime: nil, has_url_params: nil) ⇒ `ApiResponse`

Search, filter, sort, and paginate campaigns for a given Submitter CRID determines the level of access and permissions for the API. The value of this parameter should be set to “informed-delivery-campaigns” for informed-delivery-campaigns-related operations. Registration ID (CRID). before returning results. This field must be either be 0 or be a multiple of the limit variable (e.g., is limit is 10, offset can be 0, 10, 20, etc.). If no offset parameter is included at all, a default of 0 will be used. This field must be a number between 1 and 1000. If no limit parameter is included at all, a default of 100 will be used. this, an integrator can input any column that they would like to sort by (e.g., sort=brandDisplayName,desc). An integrator can indicate either an ascending or descending order by inputting asc or desc after the field name. If asc or desc is not included, then the field will be sorted ascending by default. If no sort parameter is included at all, the response will be sorted by lastModifiedDatetime,desc by default. “contains” search across the Campaign Code, Brand Display Name, and Campaign Title fields. For example inputting “Sale” will return any campaign for the CRID with a Campaign Title, Campaign Code, or Brand Display Name that contains the word “Sale”. with a NON-SEQ campaign. This count will always be 0 for MID, SEQ, and SAT campaigns. that is placed on Informed Delivery’s UIs when campaign is displayed. describes the campaign being created. This field is put into the campaign reports created for the campaign. this field will be used to match IMBs to MID and SEQ type campaigns. If an IMB has the Mailer ID (MID) associated with an active MID/SEQ campaign, it is eligible to be displayed with the campaign’s image and Target URL. types of mail pieces the campaign should be applied to * LT (Letter) * CD (Card) * FL (Flat) When filtering, either the LT/CD/FL or Letter/Card/Flat values can be used. describes the campaign being created. This field is put into the campaign reports created for the campaign. campaign should be applied to mail pieces * A01 (Non-Sequential or NON-SEQ): Individual barcodes added to campaign after submission * A02 (Mailer ID or MID): All mailpieces with given Mailer ID added to campaign

A03 (Sequential or SEQ): All mailpieces with given Mailer ID and serial

range added to campaign * A04 (Saturation or SAT): Mailpieces will be matched to saturation pieces When filtering, either the A01/A02/A03/A04 or NON-SEQ/MID/SEQ/SAT values can be used. campaign creation. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “createdDatetime>2025-07-05”). system that was originally used to create campaign (e.g. API, PO!, MCP, Admin Console). This field will not update if campaign is subsequently edited or cancelled. displayed serial range for SEQ type campaigns. This field is required for SEQ campaigns only and is not allowed for submission for any other campaign types. update made to campaign, inclusive of status changes that occur when a campaign activates or completes. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “lastModifiedDatetime>2025-07-05”). on system that was used to make last update to campaign (e.g. API, PO!, MCP, Admin Console). This field will update each time a campaign is created, edited, or cancelled. information on Cust Reg user name associated with last update to campaign. This field will update each time a campaign is created, edited, or cancelled. ID (CRID) of the Mail Owner associated with the Informed Delivery campaign. associated with the Informed Delivery campaign. PostalOne! generated unique identifier for a saturation type campaign. This field should not be used for NON-SEQ, MID, or SEQ campaigns. indicator dictating whether a campaign is eligible for Social Sharing. By default, mail campaigns will be displayed alongside options to share the campaign to various social media platforms. If a mailer opts out of this feature, then these options will not be displayed with the campaign. displayed serial range for SEQ type campaigns. This field is required for SEQ campaigns only and is not allowed for submission for any other campaign types. values include Submitted, Active, Complete, Inactive, Draft, Cancelled, and Deleted campaign submission. For this parameter to work correctly, it must be used in conjunction with a >, >=, <, or <= operator (e.g, “submittedDatetime>2025-07-05”). indicator dictating whether a campaign is eligible for MID and Serial Number parameters to be appended to the end of the Target URL for tracking purposes. By default, the MID and Serial Number parameters for a given mailpiece will be added to end of the Target URL that users are taken to upon clicking on a campaign. If a mailer opts out of this feature, then these MID and Serial Number fields will not be appended to the campaign’s Target URL.

Parameters:

scope (Scope6) —

Required parameter: The scope of the request, which
crid (String) —

Required parameter: The campaign submitter’s Customer
offset (Integer) (defaults to: 0) —

Optional parameter: Number of records to skip
limit (Integer) (defaults to: 100) —

Optional parameter: Number of results per page.
sort (String) (defaults to: nil) —

Optional parameter: Sorting order for results. To use
ezsearch (String) (defaults to: nil) —

Optional parameter: This filter will do a
barcode_count (Float) (defaults to: nil) —

Optional parameter: Number of IMBs associated
brand_display_name (String) (defaults to: nil) —

Optional parameter: User defined field
campaign_code (String) (defaults to: nil) —

Optional parameter: User defined field that
mid (String) (defaults to: nil) —

Optional parameter: The Mailer ID for the campaign -
mailpiece_shape (String) (defaults to: nil) —

Optional parameter: Identifier on what
campaign_title (String) (defaults to: nil) —

Optional parameter: User defined field that
campaign_type (String) (defaults to: nil) —

Optional parameter: Identifier on how the
created_datetime (Date) (defaults to: nil) —

Optional parameter: Date of initial
campaign_source (String) (defaults to: nil) —

Optional parameter: Gives information on
end_date (Date) (defaults to: nil) —

Optional parameter: Last day campaign will be
end_serial (String) (defaults to: nil) —

Optional parameter: The upper limit of the
last_modified_datetime (Date) (defaults to: nil) —

Optional parameter: Date of last
last_modified_source (String) (defaults to: nil) —

Optional parameter: Gives information
last_modified_username (String) (defaults to: nil) —

Optional parameter: Gives
mail_owner_crid (String) (defaults to: nil) —

Optional parameter: Customer Registration
mail_owner_name (String) (defaults to: nil) —

Optional parameter: Name of the Mail Owner
postal_one_saturation_job_id (String) (defaults to: nil) —

Optional parameter: A
is_shareable (TrueClass | FalseClass) (defaults to: nil) —

Optional parameter: An
start_date (Date) (defaults to: nil) —

Optional parameter: First day campaign will be
start_serial (String) (defaults to: nil) —

Optional parameter: The lower limit of the
status (Status) (defaults to: nil) —

Optional parameter: Status of campaign - possible
submitted_datetime (Date) (defaults to: nil) —

Optional parameter: Date of initial
has_url_params (TrueClass | FalseClass) (defaults to: nil) —

Optional parameter: An

Returns:

(ApiResponse) —

Complete http response with raw body and status code.

# File 'lib/usps_api/apis/resources_api.rb', line 1565

def query_mail_campaigns(scope,
                         crid,
                         offset: 0,
                         limit: 100,
                         sort: nil,
                         ezsearch: nil,
                         barcode_count: nil,
                         brand_display_name: nil,
                         campaign_code: nil,
                         mid: nil,
                         mailpiece_shape: nil,
                         campaign_title: nil,
                         campaign_type: nil,
                         created_datetime: nil,
                         campaign_source: nil,
                         end_date: nil,
                         end_serial: nil,
                         last_modified_datetime: nil,
                         last_modified_source: nil,
                         last_modified_username: nil,
                         mail_owner_crid: nil,
                         mail_owner_name: nil,
                         postal_one_saturation_job_id: nil,
                         is_shareable: nil,
                         start_date: nil,
                         start_serial: nil,
                         status: nil,
                         submitted_datetime: nil,
                         has_url_params: nil)
  @api_call
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/{scope}/v3/campaigns/{CRID}',
                                 Server::DEFAULT)
               .template_param(new_parameter(scope, key: 'scope')
                                .is_required(true)
                                .should_encode(true))
               .template_param(new_parameter(crid, key: 'CRID')
                                .is_required(true)
                                .should_encode(true))
               .query_param(new_parameter(offset, key: 'offset'))
               .query_param(new_parameter(limit, key: 'limit'))
               .query_param(new_parameter(sort, key: 'sort'))
               .query_param(new_parameter(ezsearch, key: 'ezsearch'))
               .query_param(new_parameter(barcode_count, key: 'barcodeCount'))
               .query_param(new_parameter(brand_display_name, key: 'brandDisplayName'))
               .query_param(new_parameter(campaign_code, key: 'campaignCode'))
               .query_param(new_parameter(mid, key: 'MID'))
               .query_param(new_parameter(mailpiece_shape, key: 'mailpieceShape'))
               .query_param(new_parameter(campaign_title, key: 'campaignTitle'))
               .query_param(new_parameter(campaign_type, key: 'campaignType'))
               .query_param(new_parameter(created_datetime, key: 'createdDatetime'))
               .query_param(new_parameter(campaign_source, key: 'campaignSource'))
               .query_param(new_parameter(end_date, key: 'endDate'))
               .query_param(new_parameter(end_serial, key: 'endSerial'))
               .query_param(new_parameter(last_modified_datetime, key: 'lastModifiedDatetime'))
               .query_param(new_parameter(last_modified_source, key: 'lastModifiedSource'))
               .query_param(new_parameter(last_modified_username, key: 'lastModifiedUsername'))
               .query_param(new_parameter(mail_owner_crid, key: 'mailOwnerCRID'))
               .query_param(new_parameter(mail_owner_name, key: 'mailOwnerName'))
               .query_param(new_parameter(postal_one_saturation_job_id, key: 'postalOneSaturationJobID'))
               .query_param(new_parameter(is_shareable, key: 'isShareable'))
               .query_param(new_parameter(start_date, key: 'startDate'))
               .query_param(new_parameter(start_serial, key: 'startSerial'))
               .query_param(new_parameter(status, key: 'status'))
               .query_param(new_parameter(submitted_datetime, key: 'submittedDatetime'))
               .query_param(new_parameter(has_url_params, key: 'hasUrlParams'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('OAuth_client_credentials')))
    .response(new_response_handler
                .deserializer(APIHelper.method(:custom_type_deserializer))
                .deserialize_into(QueryString.method(:from_hash))
                .is_api_response(true)
                .local_error('400',
                             'Bad Request',
                             InformedDeliveryCampaignsErrorException)
                .local_error('default',
                             'An unanticipated error has occurred.',
                             APIException))
    .execute
end

Class: UspsApi::ResourcesApi

Overview

Constant Summary

Constants inherited from BaseApi

Instance Attribute Summary

Attributes inherited from BaseApi

Instance Method Summary collapse

Methods inherited from BaseApi

Constructor Details

Instance Method Details

#delete_campaigns(scope, crid, campaign_id) ⇒ ApiResponse

#delete_carrier_pickup_confirmation_number(scope, confirmation_number, if_match) ⇒ ApiResponse

#delete_containers_with_container_id(scope, container_id) ⇒ ApiResponse

#delete_containers_with_container_id_with_packages(scope, container_id, tracking_number) ⇒ ApiResponse

#delete_fast_appointment(scope, body: nil) ⇒ ApiResponse

#delete_indicia_imb(scope, imb, x_payment_authorization_token) ⇒ ApiResponse

#delete_international_label(scope, tracking_number, x_payment_authorization_token) ⇒ ApiResponse

#delete_label(scope, tracking_number, x_payment_authorization_token) ⇒ ApiResponse

#delete_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ ApiResponse

#delete_package_campaigns(scope, crid, campaign_id) ⇒ ApiResponse

#delete_subscriptions_adjustment_id(scope, subscription_id, if_match) ⇒ ApiResponse

#delete_subscriptions_dispute_id(scope, subscription_id, if_match) ⇒ ApiResponse

#delete_subscriptions_ncoa_id(scope, subscription_id, if_match) ⇒ ApiResponse

#delete_subscriptions_package_transaction_details_id(scope, subscription_id, if_match) ⇒ ApiResponse

#delete_subscriptions_tracking_id(scope, subscription_id, if_match) ⇒ ApiResponse

#delete_subscriptions_unpaid_packages_id(scope, subscription_id, if_match) ⇒ ApiResponse

#get_address(scope, street_address, state, firm: nil, secondary_address: nil, city: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ ApiResponse

#get_addresses(scope, street_address, firm_name: nil, secondary_address: nil, city: nil, state: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ ApiResponse

#get_adjustments(scope, crid, tracking_number, event_type, destination_zip_code: nil) ⇒ ApiResponse

#get_appointment_availability(scope, body: nil) ⇒ ApiResponse

#get_campaigns(scope, crid, campaign_id) ⇒ ApiResponse

#get_campaigns_callback(scope, crid, offset: 0, limit: 100, sort: nil, campaign_id: nil, submitted_datetime: nil, total_barcodes: nil, total_barcodes_added: nil, total_barcodes_failed: nil) ⇒ ApiResponse

#get_carrier_pickup_confirmation_number(scope, confirmation_number) ⇒ ApiResponse

#get_carrier_pickup_eligibility(scope, street_address, secondary_address: nil, city: nil, state: nil, zip_code: nil, zip_plus4: nil, urbanization: nil) ⇒ ApiResponse

#get_city_state(scope, zip_code) ⇒ ApiResponse

#get_coa_records_search(scope, body) ⇒ ApiResponse

#get_code(scope_template, response_type, client_id, redirect_uri, user_id, scope: nil, state: nil) ⇒ ApiResponse

#get_detail_data(scope, crid, callback_key, offset: 0, limit: 10, sort: nil, error_message: nil) ⇒ ApiResponse

#get_dropoff_location(scope, destination_zip_code, destination_zip_plus4: nil, mail_class: nil, processing_category: nil, destination_entry_facility_type: nil, palletized: nil, mailing_date: nil) ⇒ ApiResponse

#get_enrollment(scope, body: nil) ⇒ ApiResponse

#get_international_base_rates_search(scope, body: nil) ⇒ ApiResponse

#get_international_extra_service_rates_search(scope, body: nil) ⇒ ApiResponse

#get_international_service_standard(scope, country_code, mail_class) ⇒ ApiResponse

#get_list_label_branding(scope, x_payment_authorization_token, limit: 10, offset: 0, order_by: OrderBy::DESC, sort_by: SortBy::CREATEDDATETIME) ⇒ ApiResponse

#get_package_tracking(tracking_number, scope, x_forwarded_for: nil, expand: Expand::SUMMARY, destination_zip_code: nil, mailing_date: nil) ⇒ ApiResponse

#get_parcel_locker_location(scope, city: nil, state: nil, zip_code: nil, offset: 0, limit: 30) ⇒ ApiResponse

#get_payment_account_account_number(scope, account_number, account_type, permit_zip_code: nil, amount: nil) ⇒ ApiResponse

#get_rate_list(scope, body: nil) ⇒ ApiResponse

#get_reconciliation_adjustments(scope, crid, event_type, start_date, start_time, end_date, end_time, page_num: 20, page_size: 20) ⇒ ApiResponse

#get_return_valid_zip5_codes(scope) ⇒ ApiResponse

#get_single_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ ApiResponse

#get_single_package_campaign(scope, crid, campaign_id) ⇒ ApiResponse

#get_subscriptions_adjustment(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

#get_subscriptions_adjustment_id(scope, subscription_id) ⇒ ApiResponse

#get_subscriptions_dispute(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

#get_subscriptions_dispute_id(scope, subscription_id) ⇒ ApiResponse

#get_subscriptions_ncoa(scope, crid: nil, offset: nil, limit: 20) ⇒ ApiResponse

#get_subscriptions_ncoa_id(scope, subscription_id) ⇒ ApiResponse

#get_subscriptions_package_transaction_details(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

#get_subscriptions_package_transaction_details_id(scope, subscription_id) ⇒ ApiResponse

#get_subscriptions_tracking(scope, mid: nil, tracking_number: nil, offset: nil, limit: 20) ⇒ ApiResponse

#get_subscriptions_tracking_id(scope, subscription_id) ⇒ ApiResponse

#get_subscriptions_unpaid_packages(scope, crid, offset: nil, limit: 20) ⇒ ApiResponse

#get_subscriptions_unpaid_packages_id(scope, subscription_id) ⇒ ApiResponse

#get_summary_data(scope, crid, callback_key) ⇒ ApiResponse

#get_user_profile(scope) ⇒ ApiResponse

#get_zip_code(scope, street_address, city, state, firm: nil, secondary_address: nil, zip_code: nil, zip_plus4: nil) ⇒ ApiResponse

#patch_label_branding(scope, image_uuid, x_payment_authorization_token, body) ⇒ ApiResponse

#patch_label_edit(scope, tracking_number, x_payment_authorization_token, body) ⇒ ApiResponse

#post_add_imb(scope, crid, campaign_id, body) ⇒ ApiResponse

#post_base_rates_search(scope, body: nil) ⇒ ApiResponse

#post_campaigns(scope, crid, body) ⇒ ApiResponse

#post_campaigns1(scope, crid, body) ⇒ ApiResponse

#post_carrier_pickup(scope, body) ⇒ ApiResponse

#post_close(scope, x_payment_authorization_token, container_id, body) ⇒ ApiResponse

#post_containers(scope, body: nil) ⇒ ApiResponse

#post_containers_with_container_id(scope, container_id, body: nil) ⇒ ApiResponse

#post_dispute(body) ⇒ ApiResponse

#post_extra_service_rates_search(scope, body: nil) ⇒ ApiResponse

#post_fast_appointment(scope, body: nil) ⇒ ApiResponse

#delete_campaigns(scope, crid, campaign_id) ⇒ `ApiResponse`

#delete_carrier_pickup_confirmation_number(scope, confirmation_number, if_match) ⇒ `ApiResponse`

#delete_containers_with_container_id(scope, container_id) ⇒ `ApiResponse`

#delete_containers_with_container_id_with_packages(scope, container_id, tracking_number) ⇒ `ApiResponse`

#delete_fast_appointment(scope, body: nil) ⇒ `ApiResponse`

#delete_indicia_imb(scope, imb, x_payment_authorization_token) ⇒ `ApiResponse`

#delete_international_label(scope, tracking_number, x_payment_authorization_token) ⇒ `ApiResponse`

#delete_label(scope, tracking_number, x_payment_authorization_token) ⇒ `ApiResponse`

#delete_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ `ApiResponse`

#delete_package_campaigns(scope, crid, campaign_id) ⇒ `ApiResponse`

#delete_subscriptions_adjustment_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

#delete_subscriptions_dispute_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

#delete_subscriptions_ncoa_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

#delete_subscriptions_package_transaction_details_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

#delete_subscriptions_tracking_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

#delete_subscriptions_unpaid_packages_id(scope, subscription_id, if_match) ⇒ `ApiResponse`

#get_address(scope, street_address, state, firm: nil, secondary_address: nil, city: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ `ApiResponse`

#get_addresses(scope, street_address, firm_name: nil, secondary_address: nil, city: nil, state: nil, urbanization: nil, zip_code: nil, zip_plus4: nil) ⇒ `ApiResponse`

#get_adjustments(scope, crid, tracking_number, event_type, destination_zip_code: nil) ⇒ `ApiResponse`

#get_appointment_availability(scope, body: nil) ⇒ `ApiResponse`

#get_campaigns(scope, crid, campaign_id) ⇒ `ApiResponse`

#get_campaigns_callback(scope, crid, offset: 0, limit: 100, sort: nil, campaign_id: nil, submitted_datetime: nil, total_barcodes: nil, total_barcodes_added: nil, total_barcodes_failed: nil) ⇒ `ApiResponse`

#get_carrier_pickup_confirmation_number(scope, confirmation_number) ⇒ `ApiResponse`

#get_carrier_pickup_eligibility(scope, street_address, secondary_address: nil, city: nil, state: nil, zip_code: nil, zip_plus4: nil, urbanization: nil) ⇒ `ApiResponse`

#get_city_state(scope, zip_code) ⇒ `ApiResponse`

#get_coa_records_search(scope, body) ⇒ `ApiResponse`

#get_code(scope_template, response_type, client_id, redirect_uri, user_id, scope: nil, state: nil) ⇒ `ApiResponse`

#get_detail_data(scope, crid, callback_key, offset: 0, limit: 10, sort: nil, error_message: nil) ⇒ `ApiResponse`

#get_dropoff_location(scope, destination_zip_code, destination_zip_plus4: nil, mail_class: nil, processing_category: nil, destination_entry_facility_type: nil, palletized: nil, mailing_date: nil) ⇒ `ApiResponse`

#get_enrollment(scope, body: nil) ⇒ `ApiResponse`

#get_international_base_rates_search(scope, body: nil) ⇒ `ApiResponse`

#get_international_extra_service_rates_search(scope, body: nil) ⇒ `ApiResponse`

#get_international_service_standard(scope, country_code, mail_class) ⇒ `ApiResponse`

#get_list_label_branding(scope, x_payment_authorization_token, limit: 10, offset: 0, order_by: OrderBy::DESC, sort_by: SortBy::CREATEDDATETIME) ⇒ `ApiResponse`

#get_package_tracking(tracking_number, scope, x_forwarded_for: nil, expand: Expand::SUMMARY, destination_zip_code: nil, mailing_date: nil) ⇒ `ApiResponse`

#get_parcel_locker_location(scope, city: nil, state: nil, zip_code: nil, offset: 0, limit: 30) ⇒ `ApiResponse`

#get_payment_account_account_number(scope, account_number, account_type, permit_zip_code: nil, amount: nil) ⇒ `ApiResponse`

#get_rate_list(scope, body: nil) ⇒ `ApiResponse`

#get_reconciliation_adjustments(scope, crid, event_type, start_date, start_time, end_date, end_time, page_num: 20, page_size: 20) ⇒ `ApiResponse`

#get_return_valid_zip5_codes(scope) ⇒ `ApiResponse`

#get_single_label_branding(scope, image_uuid, x_payment_authorization_token) ⇒ `ApiResponse`

#get_single_package_campaign(scope, crid, campaign_id) ⇒ `ApiResponse`

#get_subscriptions_adjustment(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

#get_subscriptions_adjustment_id(scope, subscription_id) ⇒ `ApiResponse`

#get_subscriptions_dispute(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

#get_subscriptions_dispute_id(scope, subscription_id) ⇒ `ApiResponse`

#get_subscriptions_ncoa(scope, crid: nil, offset: nil, limit: 20) ⇒ `ApiResponse`

#get_subscriptions_ncoa_id(scope, subscription_id) ⇒ `ApiResponse`

#get_subscriptions_package_transaction_details(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

#get_subscriptions_package_transaction_details_id(scope, subscription_id) ⇒ `ApiResponse`

#get_subscriptions_tracking(scope, mid: nil, tracking_number: nil, offset: nil, limit: 20) ⇒ `ApiResponse`

#get_subscriptions_tracking_id(scope, subscription_id) ⇒ `ApiResponse`

#get_subscriptions_unpaid_packages(scope, crid, offset: nil, limit: 20) ⇒ `ApiResponse`

#get_subscriptions_unpaid_packages_id(scope, subscription_id) ⇒ `ApiResponse`

#get_summary_data(scope, crid, callback_key) ⇒ `ApiResponse`

#get_user_profile(scope) ⇒ `ApiResponse`

#get_zip_code(scope, street_address, city, state, firm: nil, secondary_address: nil, zip_code: nil, zip_plus4: nil) ⇒ `ApiResponse`

#patch_label_branding(scope, image_uuid, x_payment_authorization_token, body) ⇒ `ApiResponse`

#patch_label_edit(scope, tracking_number, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_add_imb(scope, crid, campaign_id, body) ⇒ `ApiResponse`

#post_base_rates_search(scope, body: nil) ⇒ `ApiResponse`

#post_campaigns(scope, crid, body) ⇒ `ApiResponse`

#post_campaigns1(scope, crid, body) ⇒ `ApiResponse`

#post_carrier_pickup(scope, body) ⇒ `ApiResponse`

#post_close(scope, x_payment_authorization_token, container_id, body) ⇒ `ApiResponse`

#post_containers(scope, body: nil) ⇒ `ApiResponse`

#post_containers_with_container_id(scope, container_id, body: nil) ⇒ `ApiResponse`

#post_dispute(body) ⇒ `ApiResponse`

#post_extra_service_rates_search(scope, body: nil) ⇒ `ApiResponse`

#post_fast_appointment(scope, body: nil) ⇒ `ApiResponse`

#post_get_user_profile(scope) ⇒ `ApiResponse`

#post_indicia_imb(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_international_indicia(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_international_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ `ApiResponse`

#post_label(scope, x_payment_authorization_token, body, x_idempotency_key: nil) ⇒ `ApiResponse`

#post_label_branding(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_label_indicia(scope, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_label_reprint(scope, tracking_number, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_label_reprint1(scope, tracking_number, x_payment_authorization_token, body) ⇒ `ApiResponse`

#post_letter_rates_search(scope, body: nil) ⇒ `ApiResponse`