sound-tank 1.3.1 → 2.1.0

package/.env.example

@@ -1,2 +1,4 @@
 REVERB_API_KEY=1234567890
-REVERB_POST_KEY=1234567890
+REVERB_POST_KEY=1234567890
+
+SOUNDTANK_LOG_LEVEL=DEBUG

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+	"prettier.configPath": "prettier.config.mjs"
+}

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # sound-tank
 
+## 2.1.0
+
+### Minor Changes
+
+- f3a8df0: Add `streamAllMy()` to `ListingsResource` and `streamAllMyListings()` method. Returns an `AsyncGenerator<Listing>` that yields listings one at a time as paginated responses arrive, rather than waiting for all pages to complete.
+
+  Also adds the underlying `paginateStream<T>()` utility in `pagination.ts` for streaming any paginated endpoint.
+
+## 2.0.0
+
+### Major Changes
+
+- ce70040: Resource class architecture (v2.0 breaking change)
+  - Add `ListingsResource`, `OrdersResource` classes (`reverb.listings.getMy`, etc.)
+  - Remove flat methods from `Reverb` class; rename `getArbitraryEndpoint` -> `_getArbitraryEndpoint`
+  - Migrate all methods from axios -> `HttpClient` abstraction
+  - Remove dual `(reverb, options)` pattern; all methods now `(client, config, options)`
+  - Move `PaginatedReverbResponse` to `types.ts`
+  - Remove `getMyRoot`
+
+### Minor Changes
+
+- ce70040: Add `NegotiationsResource` (`reverb.negotiations.*`)
+  - `getNegotiations(options)` — fetch active offers grouped by listing (`/my/listings/negotiations`)
+  - `getNegotiation(offerId)` — fetch a single offer by id (`/my/negotiations/:id`)
+  - Add `Negotiation`, `NegotiationOffer`, `NegotiationPriceDisplay`, `NegotiationLinks` types to `types.ts`
+  - Add `ListingWithNegotiations` type (`Listing & { negotiations: Negotiation[] }`)
+
 ## 1.3.1
 
 ### Patch Changes

package/README.md

@@ -32,7 +32,7 @@ pnpm add sound-tank
 import Reverb from 'sound-tank';
 
 const reverb = new Reverb({ apiKey: process.env.REVERB_API_KEY });
-const { data } = await reverb.getMyListings({ perPage: 10, state: 'live' });
+const { data } = await reverb.listings.getMy({ perPage: 10, state: 'live' });
 
 data.listings.forEach(listing => {
   console.log(`${listing.title}: ${listing.price.display}`);
@@ -56,11 +56,11 @@ data.listings.forEach(listing => {
 - [Getting Started](#getting-started)
 - [Configuration](#configuration)
 - [API Methods](#api-methods)
-  - [getMyListings](#getmylistingsoptions)
-  - [getAllMyListings](#getallmylistingsoptions)
-  - [getOneListing](#getonelistingoptions)
-  - [getMyOrders](#getmyordersoptions)
-  - [getArbitraryEndpoint](#getarbitraryendpointoptions)
+  - [listings.getMy](#listingsgetmyoptions)
+  - [listings.getAllMy](#listingsgetallmyoptions)
+  - [listings.getOne](#listingsgetoneoptions)
+  - [orders.getMy](#ordersgetmyoptions)
+  - [_getArbitraryEndpoint](#_getarbitraryendpointurl-params)
 - [TypeScript Usage](#typescript-usage)
 - [Advanced Features](#advanced-features)
 - [Examples](#examples)
@@ -118,7 +118,7 @@ const reverb = new Reverb({
 ### Fetch Your Listings
 
 ```typescript
-const response = await reverb.getMyListings({
+const response = await reverb.listings.getMy({
   perPage: 25,
   page: 1,
   state: 'live',
@@ -132,7 +132,7 @@ console.log(response.data.listings);
 
 ```typescript
 try {
-  const response = await reverb.getMyListings({ state: 'live' });
+  const response = await reverb.listings.getMy({ state: 'live' });
   console.log(`Found ${response.data.listings.length} listings`);
 } catch (error) {
   console.error('Failed to fetch listings:', error.message);
@@ -167,7 +167,7 @@ These changes automatically update the internal headers and configuration for su
 
 ## API Methods
 
-### getMyListings(options?)
+### listings.getMy(options?)
 
 Fetch a paginated list of your listings.
 
@@ -181,7 +181,7 @@ Fetch a paginated list of your listings.
 
 **Example:**
 ```typescript
-const response = await reverb.getMyListings({
+const response = await reverb.listings.getMy({
   perPage: 50,
   page: 1,
   state: 'live',
@@ -194,7 +194,7 @@ console.log(`Page 1: ${listings.length} listings`);
 
 ---
 
-### getAllMyListings(options?)
+### listings.getAllMy(options?)
 
 Automatically fetches **all** listings across all pages using automatic pagination.
 
@@ -206,7 +206,7 @@ Automatically fetches **all** listings across all pages using automatic paginati
 
 **Example:**
 ```typescript
-const response = await reverb.getAllMyListings({ state: 'live' });
+const response = await reverb.listings.getAllMy({ state: 'live' });
 const allListings = response.data; // All listings from all pages
 
 console.log(`Total listings: ${allListings.length}`);
@@ -216,7 +216,7 @@ console.log(`Total listings: ${allListings.length}`);
 
 ---
 
-### getOneListing(options)
+### listings.getOne(options)
 
 Fetch a single listing by ID.
 
@@ -227,7 +227,7 @@ Fetch a single listing by ID.
 
 **Example:**
 ```typescript
-const response = await reverb.getOneListing({ id: '12345' });
+const response = await reverb.listings.getOne({ id: '12345' });
 const listing = response.data;
 
 console.log(`${listing.title} - ${listing.price.display}`);
@@ -236,7 +236,7 @@ console.log(`Condition: ${listing.condition.displayName}`);
 
 ---
 
-### getMyOrders(options?)
+### orders.getMy(options?)
 
 Fetch your orders with pagination.
 
@@ -248,7 +248,7 @@ Fetch your orders with pagination.
 
 **Example:**
 ```typescript
-const response = await reverb.getMyOrders({
+const response = await reverb.orders.getMy({
   page: 1,
   perPage: 25
 });
@@ -261,9 +261,9 @@ orders.forEach(order => {
 
 ---
 
-### getArbitraryEndpoint(options)
+### _getArbitraryEndpoint(url, params?)
 
-Make requests to any Reverb API endpoint not explicitly covered by other methods.
+Escape hatch to call any Reverb endpoint not yet wrapped by a resource. The `_` prefix indicates this is not part of the stable public API but is intentionally supported.
 
 **Parameters:**
 - `url: string` - Endpoint URL (absolute or relative to root endpoint)
@@ -274,14 +274,10 @@ Make requests to any Reverb API endpoint not explicitly covered by other methods
 **Example:**
 ```typescript
 // Fetch categories
-const categories = await reverb.getArbitraryEndpoint({
-  url: '/categories/flat'
-});
+const categories = await reverb._getArbitraryEndpoint('/categories/flat');
 
 // Fetch listing conditions
-const conditions = await reverb.getArbitraryEndpoint({
-  url: '/listing_conditions'
-});
+const conditions = await reverb._getArbitraryEndpoint('/listing_conditions');
 
 console.log(categories.data);
 ```
@@ -308,7 +304,7 @@ import Reverb, {
 ### Working with Typed Responses
 
 ```typescript
-const response = await reverb.getMyListings();
+const response = await reverb.listings.getMy();
 const listings: Listing[] = response.data.listings;
 
 listings.forEach((listing: Listing) => {
@@ -361,13 +357,13 @@ let allListings = [];
 let response;
 
 do {
-  response = await reverb.getMyListings({ page, perPage: 50 });
+  response = await reverb.listings.getMy({ page, perPage: 50 });
   allListings = allListings.concat(response.data.listings);
   page++;
 } while (response.data.listings.length === 50);
 
 // Or use the built-in helper
-const autoResponse = await reverb.getAllMyListings();
+const autoResponse = await reverb.listings.getAllMy();
 const listings = autoResponse.data; // Same result, simpler code
 ```
 
@@ -405,7 +401,7 @@ console.log(headers['X-Display-Currency']); // 'USD'
 ```typescript
 const reverb = new Reverb({ apiKey: process.env.REVERB_API_KEY });
 
-const response = await reverb.getAllMyListings({ query: 'guitar' });
+const response = await reverb.listings.getAllMy({ query: 'guitar' });
 const affordable = response.data.filter(listing =>
   listing.price.amount_cents < 100000 // $1000 = 100,000 cents
 );
@@ -423,7 +419,7 @@ const reverb = new Reverb({ apiKey: process.env.REVERB_API_KEY });
 
 // Get prices in USD
 reverb.displayCurrency = 'USD';
-const usdResponse = await reverb.getMyListings({ perPage: 5 });
+const usdResponse = await reverb.listings.getMy({ perPage: 5 });
 console.log('USD Prices:');
 usdResponse.data.listings.forEach(l =>
   console.log(`  ${l.title}: ${l.price.display}`)
@@ -431,7 +427,7 @@ usdResponse.data.listings.forEach(l =>
 
 // Switch to EUR
 reverb.displayCurrency = 'EUR';
-const eurResponse = await reverb.getMyListings({ perPage: 5 });
+const eurResponse = await reverb.listings.getMy({ perPage: 5 });
 console.log('\nEUR Prices:');
 eurResponse.data.listings.forEach(l =>
   console.log(`  ${l.title}: ${l.price.display}`)
@@ -441,7 +437,7 @@ eurResponse.data.listings.forEach(l =>
 ### Export Listings to CSV
 
 ```typescript
-const response = await reverb.getAllMyListings({ state: 'live' });
+const response = await reverb.listings.getAllMy({ state: 'live' });
 
 const csvHeader = 'ID,Title,Price,Currency,Condition,Year,State\n';
 const csvRows = response.data.map(listing =>
@@ -457,7 +453,7 @@ console.log(csv);
 
 ```typescript
 // Search for specific items
-const response = await reverb.getMyListings({
+const response = await reverb.listings.getMy({
   query: 'Les Paul',
   state: 'live',
   perPage: 100
@@ -514,9 +510,12 @@ sound-tank/
 │   │   ├── AxiosHttpClient.ts    # Axios implementation
 │   │   └── MockHttpClient.ts     # Mock for testing
 │   ├── methods/
-│   │   ├── listings/       # Listing operations
-│   │   └── orders/         # Order operations
-│   └── utils/              # Helper utilities
+│   │   ├── listings/       # Listing operations (pure functions)
+│   │   └── orders/         # Order operations (pure functions)
+│   ├── resources/
+│   │   ├── ListingsResource.ts   # Listings resource class
+│   │   └── OrdersResource.ts     # Orders resource class
+│   └── utils/              # Helper utilities (pagination, url/query builders, logger)
 ├── tests/                  # Test files
 ├── dist/                   # Build output (git-ignored)
 ├── package.json
@@ -525,6 +524,16 @@ sound-tank/
 └── vite.config.mts         # Test configuration
 ```
 
+### Debugging
+
+Set `SOUNDTANK_LOG_LEVEL` to enable SDK logging:
+
+```bash
+SOUNDTANK_LOG_LEVEL=DEBUG yarn dev
+```
+
+Valid values: `ERROR | WARN | INFO | DEBUG | TRACE`. Silent by default.
+
 ### Available Scripts
 
 | Command | Description |

package/dist/index.d.mts

@@ -1,5 +1,94 @@
-import * as axios from 'axios';
-import { Axios } from 'axios';
+interface HttpRequestConfig {
+    headers?: Record<string, string | undefined>;
+    params?: Record<string, string | number | boolean | undefined | null>;
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+    [key: string]: any;
+}
+/**
+ * HTTP response structure compatible with AxiosResponse
+ */
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: HttpRequestConfig;
+    request?: any;
+}
+
+/**
+ * Abstract HTTP client interface for making API requests.
+ * This abstraction allows for different implementations (e.g., axios, fetch, mock)
+ * while keeping the business logic decoupled from the HTTP layer.
+ */
+interface HttpClient {
+    /**
+     * @example
+     * ```ts
+     * const response = await client.get<User>('/api/users/123', {
+     *   headers: { 'Authorization': 'Bearer token' }
+     * });
+     * console.log(response.data);
+     * ```
+     */
+    get<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    /**
+     * @example
+     * ```ts
+     * const response = await client.post<User>('/api/users', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com'
+     * }, {
+     *   headers: { 'Authorization': 'Bearer token' }
+     * });
+     * ```
+     */
+    post<T = any>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    /**
+     * @example
+     * ```ts
+     * const response = await client.put<User>('/api/users/123', {
+     *   name: 'Jane Doe'
+     * }, {
+     *   headers: { 'Authorization': 'Bearer token' }
+     * });
+     * ```
+     */
+    put<T = any>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    /**
+     * @example
+     * ```ts
+     * const response = await client.delete('/api/users/123', {
+     *   headers: { 'Authorization': 'Bearer token' }
+     * });
+     * ```
+     */
+    delete<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    /**
+     * @example
+     * ```ts
+     * const response = await client.patch<User>('/api/users/123', {
+     *   email: 'newemail@example.com'
+     * }, {
+     *   headers: { 'Authorization': 'Bearer token' }
+     * });
+     * ```
+     */
+    patch<T = any>(url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+}
+
+interface ReverbConfig {
+    rootEndpoint: RootEndpoint;
+    apiKey: ApiKey;
+    headers: AuthReverbHeaders;
+    version: ApiVersion;
+    locale: Locale;
+    displayCurrency: DisplayCurrency;
+    shippingRegion?: ShippingRegion;
+}
 
 declare enum LinkMethods {
     PUT = "PUT",
@@ -107,6 +196,48 @@ type Listing = {
     }[];
     _links: ListingLinks;
 };
+type ListingPostBody = {
+    make: string;
+    model: string;
+    categories: {
+        uuid: string;
+    }[];
+    condition: {
+        uuid: string;
+    };
+    photos: string[];
+    videos: [
+        {
+            link: string;
+        }
+    ];
+    description: string;
+    finish: string;
+    price: {
+        amount: string;
+        currency: string;
+    };
+    title: string;
+    year: string;
+    sku: string;
+    upc: string;
+    upc_does_not_apply: `${boolean}`;
+    has_inventory: boolean;
+    inventory: number;
+    offers_enabled: boolean;
+    handmade: boolean;
+    shipping_profile_id?: string;
+    shipping?: {
+        rates: {
+            rate: {
+                amount: string;
+                currency: string;
+            };
+            region_code: string;
+        }[];
+        local: boolean;
+    };
+};
 declare enum OrderStatusOptions {
     Unpaid = "unpaid",
     Paid = "paid",
@@ -236,42 +367,72 @@ type ShippingAddress = {
         self: Link;
     };
 };
-
-/**
- * Configuration object for Reverb API operations.
- * This contains all necessary settings to make API requests without requiring
- * the entire Reverb instance to be passed around.
- */
-interface ReverbConfig {
-    /**
-     * The root API endpoint URL
-     */
-    rootEndpoint: RootEndpoint;
-    /**
-     * The API key for authentication
-     */
-    apiKey: ApiKey;
-    /**
-     * Complete headers including authentication
-     */
-    headers: AuthReverbHeaders;
-    /**
-     * API version to use
-     */
-    version: ApiVersion;
-    /**
-     * Locale for API responses
-     */
-    locale: Locale;
-    /**
-     * Display currency for prices
-     */
-    displayCurrency: DisplayCurrency;
-    /**
-     * Optional shipping region
-     */
-    shippingRegion?: ShippingRegion;
-}
+type PaginatedReverbResponse<T> = T & {
+    total: number;
+    current_page: number;
+    total_pages: number;
+    _links: {
+        next?: Link;
+        prev?: Link;
+    };
+};
+type NegotiationPriceDisplay = {
+    original: Price;
+    display: Price;
+};
+type NegotiationOffer = {
+    created_at: string;
+    message: string;
+    price: NegotiationPriceDisplay;
+    shipping_price: NegotiationPriceDisplay;
+    total_price: NegotiationPriceDisplay;
+    initiated_by_name: string;
+    initiated_by_shop_name: string;
+    initiated_by_me: boolean;
+    initiator_type: 'seller' | 'buyer' | Exclude<string, 'seller' | 'buyer'>;
+};
+type NegotiationLinks = {
+    listing: Link;
+    self: Link;
+    counter: Link;
+    accept: Link;
+    decline: Link;
+};
+type Negotiation = {
+    id: number | string;
+    state: 'active' | 'accepted' | 'declined' | 'expired' | Exclude<string, 'active' | 'accepted' | 'declined' | 'expired'>;
+    offers_count: number;
+    expires_at: string;
+    created_at: string;
+    updated_at: string;
+    buyer_name: string;
+    buyer_id: number | string;
+    seller_name: string;
+    shop_id?: number | string;
+    shop_name: string;
+    other_party_name: string;
+    other_party?: {
+        _links: {
+            avatar: Link;
+        };
+        profile_slug: string | null;
+    };
+    actionable: boolean;
+    you_last_initiated?: boolean;
+    can_ship_to_buyer: boolean;
+    buyer_shipping_region_code: string;
+    buyer_address: ShippingAddress & {
+        uuid?: string;
+    };
+    last_offered_price: NegotiationPriceDisplay;
+    last_offered_shipping: NegotiationPriceDisplay;
+    last_offered_total: NegotiationPriceDisplay;
+    offers?: NegotiationOffer[];
+    _links: NegotiationLinks;
+};
+type ListingWithNegotiations = Listing & {
+    negotiations: Negotiation[];
+};
 
 interface GetMyListingsOptions {
     page?: number;
@@ -287,19 +448,50 @@ interface GetOneListingOptions {
     id: string;
 }
 
+declare class ListingsResource {
+    private getClient;
+    private getConfig;
+    constructor(getClient: () => HttpClient, getConfig: () => ReverbConfig);
+    getMy(options?: GetMyListingsOptions): Promise<HttpResponse<PaginatedReverbResponse<{
+        listings: Listing[];
+    }>>>;
+    getOne(options: GetOneListingOptions): Promise<HttpResponse<Listing>>;
+    getPhotos(options: GetOneListingOptions): Promise<string[]>;
+    getAllMy(options?: GetAllMyListingsOptions): Promise<HttpResponse<Listing[]>>;
+    streamAllMy(options?: GetAllMyListingsOptions): AsyncGenerator<Listing, any, any>;
+    create(body: ListingPostBody): Promise<HttpResponse<Listing>>;
+}
+
 interface GetMyOrdersOptions {
     page?: number;
 }
 
-type PaginatedReverbResponse<T> = T & {
-    total: number;
-    current_page: number;
-    total_pages: number;
-    _links: {
-        next?: Link;
-        prev?: Link;
-    };
-};
+declare class OrdersResource {
+    private getClient;
+    private getConfig;
+    constructor(getClient: () => HttpClient, getConfig: () => ReverbConfig);
+    getMy(options?: GetMyOrdersOptions): Promise<HttpResponse<PaginatedReverbResponse<{
+        orders: Order[];
+    }>>>;
+}
+
+interface GetNegotiationsOptions {
+    page?: number;
+    perPage?: number;
+    status?: 'active' | 'active_for_seller' | 'all';
+    negotiation_type?: 'standard' | 'auto_push_offer';
+}
+
+declare class NegotiationsResource {
+    private getClient;
+    private getConfig;
+    constructor(getClient: () => HttpClient, getConfig: () => ReverbConfig);
+    getNegotiations(options: GetNegotiationsOptions): Promise<HttpResponse<PaginatedReverbResponse<{
+        listings: ListingWithNegotiations[];
+    }>>>;
+    getNegotiation(offerId: number): Promise<HttpResponse<Negotiation>>;
+}
+
 type GetArbitraryEndpointOptions = {
     url: string;
     params?: {
@@ -322,14 +514,15 @@ interface ReverbOptions {
     shippingRegion?: ShippingRegion | undefined;
     locale?: Locale | undefined;
 }
-type ReverbHeaders = Axios['get']['arguments'][1] & {
-    'Content-Type': string;
-    'Accept-Version': ApiVersion;
+type ReverbHeaders = {
+    "Content-Type": string;
+    "Accept-Version": ApiVersion;
     Accept: string;
-    'Accept-Language': Locale;
-    'X-Display-Currency': DisplayCurrency;
-    'X-Shipping-Region'?: ShippingRegion | undefined;
-    'User-Agent'?: string;
+    "Accept-Language": Locale;
+    "X-Display-Currency": DisplayCurrency;
+    "X-Shipping-Region"?: ShippingRegion | undefined;
+    "User-Agent"?: string;
+    [key: string]: string | undefined;
 };
 interface AuthReverbHeaders extends ReverbHeaders {
     Authorization: `Bearer ${ApiKey}`;
@@ -345,16 +538,11 @@ declare class Reverb {
     private _locale;
     private _config;
     private _httpClient;
+    readonly listings: ListingsResource;
+    readonly orders: OrdersResource;
+    readonly negotiations: NegotiationsResource;
     constructor(options: ReverbOptions);
-    /**
-     * Updates the headers based on the current state of the Reverb instance.
-     * This method is called whenever a property that affects the headers is changed, rather than every time a request is made.
-     */
     private updateHeaders;
-    /**
-     * Updates the internal config object based on current state.
-     * This is called whenever configuration-related properties change.
-     */
     private _updateConfig;
     set locale(locale: Locale);
     get locale(): Locale;
@@ -367,46 +555,8 @@ declare class Reverb {
     get version(): ApiVersion;
     set rootEndpoint(rootEndpoint: RootEndpoint);
     get rootEndpoint(): RootEndpoint;
-    /**
-     * Gets the current configuration object.
-     * This provides access to all configuration values in a single object,
-     * useful for passing to methods without requiring the entire Reverb instance.
-     */
     get config(): ReverbConfig;
-    /**
-     * Retrieves the current user's listings.
-     * @param {methods.GetMyListingsOptions} options - Optional parameters for the request.
-     * @returns {Promise<AxiosResponse<PaginatedReverbResponse<{ listings: Listing[] }>>>} A Promise that resolves to the user's listings. Structured as an axios response
-     */
-    getMyListings(options?: GetMyListingsOptions): Promise<axios.AxiosResponse<PaginatedReverbResponse<{
-        listings: Listing[];
-    }>, any, {}>>;
-    /**
-     * Retrieves the orders for the current user.
-     * @param {methods.GetMyOrdersOptions} options - An optional object containing options for the request.
-     * @returns {Promise<AxiosResponse<PaginatedReverbResponse<{ orders: Order[] }>>>} A Promise that resolves with the user's orders. Structured as an axios response
-     */
-    getMyOrders(options?: GetMyOrdersOptions): Promise<axios.AxiosResponse<PaginatedReverbResponse<{
-        orders: Order[];
-    }>, any, {}>>;
-    /**
-     * Retrieves an arbitrary endpoint using the provided options.
-     * @param {methods.GetArbitraryEndpointOptions} options - The options to use when retrieving the endpoint.
-     * @returns {Promise<AxiosResponse<unknown>>} A Promise that resolves with the retrieved endpoint. Structured as an axios response
-     */
-    getArbitraryEndpoint(options: GetArbitraryEndpointOptions): Promise<axios.AxiosResponse<any, any, {}>>;
-    /**
-     * Retrieves a single listing based on the provided options.
-     * @param {methods.GetOneListingOptions} options - The options to use when retrieving the listing.
-     * @returns {Promise<AxiosResponse<Listing>>} A Promise that resolves with the retrieved listing.
-     */
-    getOneListing(options: GetOneListingOptions): Promise<axios.AxiosResponse<Listing, any, {}>>;
-    /**
-     * Retrieves all listings associated with the current user.
-     * @param {methods.GetAllMyListingsOptions} options - An optional object containing options for the request.
-     * @returns {Promise<AxiosResponse<PaginatedReverbResponse<{ listings: Listing[] }>>>} A Promise that resolves with an array of listings.
-     */
-    getAllMyListings(options?: GetAllMyListingsOptions): Promise<axios.AxiosResponse<Listing[], any, {}>>;
+    _getArbitraryEndpoint<T = any>(url: string, params?: GetArbitraryEndpointOptions["params"]): Promise<HttpResponse<T>>;
 }
 
-export { type ApiKey, type ApiVersion, type AuthReverbHeaders, type DisplayCurrency, type Locale, type ReverbHeaders, type ReverbOptions, type RootEndpoint, type ShippingRegion, Reverb as default };
+export { type ApiKey, type ApiVersion, type AuthReverbHeaders, type DisplayCurrency, ListingsResource, type Locale, OrdersResource, type ReverbHeaders, type ReverbOptions, type RootEndpoint, type ShippingRegion, Reverb as default };