@profplum700/etsy-v3-api-client 1.0.1 → 2.3.1

package/dist/node.cjs

@@ -3,11 +3,22 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class EtsyApiError extends Error {
-    constructor(message, _statusCode, _response) {
+    constructor(message, _statusCode, _response, _retryAfter) {
         super(message);
         this._statusCode = _statusCode;
         this._response = _response;
+        this._retryAfter = _retryAfter;
         this.name = 'EtsyApiError';
+        this.details = {
+            statusCode: _statusCode || 0,
+            retryAfter: _retryAfter
+        };
+        if (_response && typeof _response === 'object') {
+            const resp = _response;
+            this.details.errorCode = (resp.error_code || resp.code);
+            this.details.field = resp.field;
+            this.details.suggestion = (resp.suggestion || resp.message);
+        }
     }
     get statusCode() {
         return this._statusCode;
@@ -15,6 +26,47 @@ class EtsyApiError extends Error {
     get response() {
         return this._response;
     }
+    isRetryable() {
+        if (!this._statusCode) {
+            return false;
+        }
+        if (this._statusCode === 429) {
+            return true;
+        }
+        if (this._statusCode >= 500 && this._statusCode < 600) {
+            return true;
+        }
+        const retryableClientErrors = [408, 409, 423, 425];
+        if (retryableClientErrors.includes(this._statusCode)) {
+            return true;
+        }
+        return false;
+    }
+    getRetryAfter() {
+        return this._retryAfter || null;
+    }
+    getRateLimitReset() {
+        if (this._statusCode !== 429 || !this._retryAfter) {
+            return null;
+        }
+        return new Date(Date.now() + this._retryAfter * 1000);
+    }
+    getUserFriendlyMessage() {
+        let message = this.message;
+        if (this.details.suggestion) {
+            message += `\nSuggestion: ${this.details.suggestion}`;
+        }
+        if (this.isRetryable()) {
+            const retryAfter = this.getRetryAfter();
+            if (retryAfter) {
+                message += `\nRetry after ${retryAfter} seconds.`;
+            }
+            else {
+                message += '\nThis error can be retried.';
+            }
+        }
+        return message;
+    }
 }
 class EtsyAuthError extends Error {
     constructor(message, _code) {
@@ -106,11 +158,12 @@ class MemoryTokenStorage {
     }
 }
 class TokenManager {
-    constructor(config, storage) {
+    constructor(config, storage, rotationConfig) {
         this.currentTokens = null;
         this.keystring = config.keystring;
         this.refreshCallback = config.refreshSave;
         this.storage = storage;
+        this.rotationConfig = rotationConfig;
         this.currentTokens = {
             access_token: config.accessToken,
             refresh_token: config.refreshToken,
@@ -118,6 +171,9 @@ class TokenManager {
             token_type: 'Bearer',
             scope: ''
         };
+        if (this.rotationConfig?.enabled && this.rotationConfig?.autoSchedule) {
+            this.startRotationScheduler();
+        }
     }
     async getAccessToken() {
         if (!this.currentTokens) {
@@ -178,8 +234,7 @@ class TokenManager {
                 body: body.toString()
             });
             if (!response.ok) {
-                const errorText = await response.text();
-                throw new EtsyAuthError(`Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`, 'TOKEN_REFRESH_FAILED');
+                throw new EtsyAuthError(`Token refresh failed: ${response.status} ${response.statusText}`, 'TOKEN_REFRESH_FAILED');
             }
             const tokenResponse = await response.json();
             return {
@@ -234,6 +289,73 @@ class TokenManager {
         const expiresAt = new Date(this.currentTokens.expires_at);
         return expiresAt.getTime() - now.getTime();
     }
+    needsProactiveRotation() {
+        if (!this.rotationConfig?.enabled || !this.currentTokens) {
+            return false;
+        }
+        const timeUntilExpiration = this.getTimeUntilExpiration();
+        if (timeUntilExpiration === null) {
+            return false;
+        }
+        const rotateBeforeExpiry = this.rotationConfig.rotateBeforeExpiry || 15 * 60 * 1000;
+        return timeUntilExpiration <= rotateBeforeExpiry;
+    }
+    async rotateToken() {
+        if (!this.currentTokens) {
+            throw new EtsyAuthError('No tokens available to rotate', 'NO_TOKENS');
+        }
+        const oldTokens = { ...this.currentTokens };
+        const newTokens = await this.refreshToken();
+        if (this.rotationConfig?.onRotation) {
+            try {
+                await Promise.resolve(this.rotationConfig.onRotation(oldTokens, newTokens));
+            }
+            catch (error) {
+                console.error('Token rotation callback failed:', error);
+            }
+        }
+        return newTokens;
+    }
+    startRotationScheduler() {
+        if (!this.rotationConfig?.enabled) {
+            throw new Error('Token rotation is not enabled');
+        }
+        this.stopRotationScheduler();
+        const checkInterval = this.rotationConfig.checkInterval || 60 * 1000;
+        this.rotationTimer = setInterval(async () => {
+            try {
+                if (this.needsProactiveRotation()) {
+                    console.log('Proactively rotating token before expiration');
+                    await this.rotateToken();
+                }
+            }
+            catch (error) {
+                console.error('Failed to proactively rotate token:', error);
+            }
+        }, checkInterval);
+        if (this.rotationTimer.unref) {
+            this.rotationTimer.unref();
+        }
+    }
+    stopRotationScheduler() {
+        if (this.rotationTimer) {
+            clearInterval(this.rotationTimer);
+            this.rotationTimer = undefined;
+        }
+    }
+    updateRotationConfig(config) {
+        const wasAutoScheduleEnabled = this.rotationConfig?.autoSchedule;
+        this.rotationConfig = config;
+        if (config.enabled && config.autoSchedule && !wasAutoScheduleEnabled) {
+            this.startRotationScheduler();
+        }
+        else if (!config.enabled || !config.autoSchedule) {
+            this.stopRotationScheduler();
+        }
+    }
+    getRotationConfig() {
+        return this.rotationConfig ? { ...this.rotationConfig } : undefined;
+    }
     async fetch(url, options) {
         assertFetchSupport();
         return fetch(url, options);
@@ -330,6 +452,7 @@ class FileTokenStorage {
         try {
             const data = JSON.stringify(tokens, null, 2);
             await this._writeFile(this.filePath, data);
+            await this._setFilePermissions(this.filePath, 0o600);
         }
         catch {
             throw new Error('Failed to save tokens to file');
@@ -367,6 +490,16 @@ class FileTokenStorage {
         const fs = await import('fs');
         await fs.promises.writeFile(filePath, data, 'utf8');
     }
+    async _setFilePermissions(filePath, mode) {
+        if (typeof process === 'undefined')
+            return;
+        try {
+            const fs = await import('fs');
+            await fs.promises.chmod(filePath, mode);
+        }
+        catch {
+        }
+    }
     async _readFile(filePath) {
         if (typeof process === 'undefined')
             throw new Error('Not available');
@@ -464,6 +597,407 @@ class EtsyRateLimiter {
 }
 const defaultRateLimiter = new EtsyRateLimiter();
 
+class BulkOperationManager {
+    constructor(config = {}) {
+        this.concurrency = config.concurrency ?? 5;
+        this.stopOnError = config.stopOnError ?? false;
+        this.onProgress = config.onProgress;
+        this.onItemComplete = config.onItemComplete;
+        this.onItemError = config.onItemError;
+    }
+    async executeBulk(items, operation, getId) {
+        const startTime = Date.now();
+        const results = [];
+        const errors = [];
+        let completed = 0;
+        let successful = 0;
+        let failed = 0;
+        const queue = items.map((item, index) => ({
+            item,
+            index,
+            id: getId ? getId(item, index) : index
+        }));
+        const workers = [];
+        for (let i = 0; i < Math.min(this.concurrency, items.length); i++) {
+            workers.push(this.worker(queue, operation, results, errors, () => {
+                completed++;
+                const lastResult = results[results.length - 1];
+                if (lastResult?.success) {
+                    successful++;
+                }
+                else {
+                    failed++;
+                }
+                if (this.onProgress) {
+                    this.onProgress(completed, items.length, lastResult);
+                }
+            }));
+        }
+        await Promise.all(workers);
+        const duration = Date.now() - startTime;
+        return {
+            total: items.length,
+            successful,
+            failed,
+            results,
+            errors,
+            duration
+        };
+    }
+    async worker(queue, operation, results, errors, onComplete) {
+        while (queue.length > 0) {
+            const work = queue.shift();
+            if (!work)
+                break;
+            const { item, index, id } = work;
+            try {
+                const data = await operation(item, index);
+                const result = {
+                    success: true,
+                    data,
+                    id,
+                    index
+                };
+                results.push(result);
+                if (this.onItemComplete) {
+                    this.onItemComplete(result);
+                }
+                onComplete();
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                const result = {
+                    success: false,
+                    error: err,
+                    id,
+                    index
+                };
+                results.push(result);
+                const bulkError = {
+                    id,
+                    index,
+                    error: err
+                };
+                errors.push(bulkError);
+                if (this.onItemError) {
+                    this.onItemError(bulkError);
+                }
+                onComplete();
+                if (this.stopOnError) {
+                    queue.length = 0;
+                    break;
+                }
+            }
+        }
+    }
+    setConcurrency(concurrency) {
+        this.concurrency = Math.max(1, concurrency);
+    }
+    getConcurrency() {
+        return this.concurrency;
+    }
+}
+function createBulkOperationManager(config) {
+    return new BulkOperationManager(config);
+}
+async function executeBulkOperation(items, operation, config) {
+    const manager = new BulkOperationManager(config);
+    return manager.executeBulk(items, operation);
+}
+
+class Validator {
+    constructor() {
+        this.validators = [];
+    }
+    rule(validator) {
+        this.validators.push(validator);
+        return this;
+    }
+    validate(data) {
+        const errors = [];
+        for (const validator of this.validators) {
+            const error = validator(data);
+            if (error) {
+                errors.push(error);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}
+class FieldValidator {
+    constructor(field) {
+        this.field = field;
+    }
+    required(message) {
+        return (data) => {
+            if (typeof data !== 'object' || data === null)
+                return null;
+            const value = data[this.field];
+            if (value === undefined || value === null || value === '') {
+                return {
+                    field: this.field,
+                    message: message || `${this.field} is required`,
+                    value
+                };
+            }
+            return null;
+        };
+    }
+    string(options) {
+        return (data) => {
+            if (typeof data !== 'object' || data === null)
+                return null;
+            const value = data[this.field];
+            if (value === undefined || value === null)
+                return null;
+            if (typeof value !== 'string') {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be a string`,
+                    value
+                };
+            }
+            if (options.min !== undefined && value.length < options.min) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be at least ${options.min} characters`,
+                    value
+                };
+            }
+            if (options.max !== undefined && value.length > options.max) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be at most ${options.max} characters`,
+                    value
+                };
+            }
+            if (options.pattern && !options.pattern.test(value)) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} has invalid format`,
+                    value
+                };
+            }
+            return null;
+        };
+    }
+    number(options) {
+        return (data) => {
+            if (typeof data !== 'object' || data === null)
+                return null;
+            const value = data[this.field];
+            if (value === undefined || value === null)
+                return null;
+            if (typeof value !== 'number' || isNaN(value)) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be a number`,
+                    value
+                };
+            }
+            if (options.integer && !Number.isInteger(value)) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be an integer`,
+                    value
+                };
+            }
+            if (options.positive && value <= 0) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be positive`,
+                    value
+                };
+            }
+            if (options.min !== undefined && value < options.min) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be at least ${options.min}`,
+                    value
+                };
+            }
+            if (options.max !== undefined && value > options.max) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be at most ${options.max}`,
+                    value
+                };
+            }
+            return null;
+        };
+    }
+    enum(allowedValues, message) {
+        return (data) => {
+            if (typeof data !== 'object' || data === null)
+                return null;
+            const value = data[this.field];
+            if (value === undefined || value === null)
+                return null;
+            if (!allowedValues.includes(value)) {
+                return {
+                    field: this.field,
+                    message: message || `${this.field} must be one of: ${allowedValues.join(', ')}`,
+                    value
+                };
+            }
+            return null;
+        };
+    }
+    array(options) {
+        return (data) => {
+            if (typeof data !== 'object' || data === null)
+                return null;
+            const value = data[this.field];
+            if (value === undefined || value === null)
+                return null;
+            if (!Array.isArray(value)) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must be an array`,
+                    value
+                };
+            }
+            if (options.min !== undefined && value.length < options.min) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must have at least ${options.min} items`,
+                    value
+                };
+            }
+            if (options.max !== undefined && value.length > options.max) {
+                return {
+                    field: this.field,
+                    message: options.message || `${this.field} must have at most ${options.max} items`,
+                    value
+                };
+            }
+            if (options.itemValidator) {
+                for (let i = 0; i < value.length; i++) {
+                    if (!options.itemValidator(value[i])) {
+                        return {
+                            field: this.field,
+                            message: options.message || `${this.field}[${i}] has invalid value`,
+                            value: value[i]
+                        };
+                    }
+                }
+            }
+            return null;
+        };
+    }
+}
+function field(fieldName) {
+    return new FieldValidator(fieldName);
+}
+const CreateListingSchema = new Validator()
+    .rule(field('quantity').required())
+    .rule(field('quantity').number({ min: 1, integer: true, message: 'quantity must be a positive integer' }))
+    .rule(field('title').required())
+    .rule(field('title').string({ min: 1, max: 140, message: 'title must be 1-140 characters' }))
+    .rule(field('description').string({ max: 65535, message: 'description must be less than 65535 characters' }))
+    .rule(field('price').required())
+    .rule(field('price').number({ min: 0.2, max: 50000, message: 'price must be between 0.20 and 50000.00' }))
+    .rule(field('who_made').enum(['i_did', 'someone_else', 'collective'], 'who_made must be one of: i_did, someone_else, collective'))
+    .rule(field('when_made').enum([
+    'made_to_order',
+    '2020_2024',
+    '2010_2019',
+    '2005_2009',
+    '2000_2004',
+    '1990s',
+    '1980s',
+    '1970s',
+    '1960s',
+    '1950s',
+    '1940s',
+    '1930s',
+    '1920s',
+    '1910s',
+    '1900s',
+    '1800s',
+    '1700s',
+    'before_1700'
+]))
+    .rule(field('taxonomy_id').required())
+    .rule(field('taxonomy_id').number({ integer: true, positive: true, message: 'taxonomy_id must be a positive integer' }));
+const UpdateListingSchema = new Validator()
+    .rule((data) => {
+    if (typeof data === 'object' && data !== null && 'title' in data && data.title !== undefined) {
+        return field('title').string({ min: 1, max: 140, message: 'title must be 1-140 characters' })(data);
+    }
+    return null;
+})
+    .rule((data) => {
+    if (typeof data === 'object' && data !== null && 'description' in data && data.description !== undefined) {
+        return field('description').string({ max: 65535, message: 'description must be less than 65535 characters' })(data);
+    }
+    return null;
+})
+    .rule((data) => {
+    if (data.tags !== undefined) {
+        return field('tags').array({ max: 13, message: 'tags must have at most 13 items' })(data);
+    }
+    return null;
+})
+    .rule((data) => {
+    if (data.materials !== undefined) {
+        return field('materials').array({ max: 13, message: 'materials must have at most 13 items' })(data);
+    }
+    return null;
+});
+const UpdateShopSchema = new Validator()
+    .rule((data) => {
+    if (typeof data === 'object' && data !== null && 'title' in data && data.title !== undefined) {
+        return field('title').string({ min: 1, max: 55, message: 'shop title must be 1-55 characters' })(data);
+    }
+    return null;
+})
+    .rule((data) => {
+    if (typeof data === 'object' && data !== null && 'announcement' in data && data.announcement !== undefined) {
+        return field('announcement').string({ max: 5000, message: 'announcement must be less than 5000 characters' })(data);
+    }
+    return null;
+});
+class ValidationException extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.name = 'ValidationException';
+        this.errors = errors;
+    }
+}
+function validateOrThrow(data, schema, errorMessage = 'Validation failed') {
+    const result = schema.validate(data);
+    if (!result.valid) {
+        throw new ValidationException(errorMessage, result.errors);
+    }
+}
+function validate(data, schema) {
+    return schema.validate(data);
+}
+function createValidator() {
+    return new Validator();
+}
+function combineValidators(...validators) {
+    return {
+        validate(data) {
+            const allErrors = [];
+            for (const validator of validators) {
+                const result = validator.validate(data);
+                if (!result.valid) {
+                    allErrors.push(...result.errors);
+                }
+            }
+            return {
+                valid: allErrors.length === 0,
+                errors: allErrors
+            };
+        }
+    };
+}
+
 class DefaultLogger {
     debug(message, ...args) {
         const isDevelopment = isNode$1
@@ -528,6 +1062,10 @@ class EtsyClient {
             this.cache = config.caching?.storage || new MemoryCache();
             this.cacheTtl = config.caching?.ttl || 3600;
         }
+        this.bulkOperationManager = new BulkOperationManager({
+            concurrency: 5,
+            stopOnError: false
+        });
     }
     async makeRequest(endpoint, options = {}, useCache = true) {
         const url = `${this.baseUrl}${endpoint}`;
@@ -560,6 +1098,13 @@ class EtsyClient {
                 const errorText = await response.text();
                 throw new EtsyApiError(`Etsy API error: ${response.status} ${response.statusText}`, response.status, errorText);
             }
+            if (response.status === 204) {
+                return undefined;
+            }
+            const contentLength = response.headers?.get?.('content-length');
+            if (contentLength === '0') {
+                return undefined;
+            }
             const data = await response.json();
             if (useCache && this.cache && requestOptions.method === 'GET') {
                 await this.cache.set(cacheKey, JSON.stringify(data), this.cacheTtl);
@@ -670,6 +1215,278 @@ class EtsyClient {
     async getListingInventory(listingId) {
         return this.makeRequest(`/listings/${listingId}/inventory`);
     }
+    async getSellerTaxonomyNodes() {
+        const response = await this.makeRequest('/seller-taxonomy/nodes');
+        return response.results;
+    }
+    async getUserShops() {
+        const response = await this.makeRequest('/users/me/shops');
+        return response.results || [];
+    }
+    async updateShop(shopId, params, options) {
+        if (options?.validate) {
+            const schema = options.validateSchema || UpdateShopSchema;
+            const throwOnError = options.throwOnValidationError !== false;
+            if (throwOnError) {
+                validateOrThrow(params, schema, 'Invalid shop update parameters');
+            }
+            else {
+                const result = schema.validate(params);
+                if (!result.valid) {
+                    this.logger.warn('Shop update validation failed', result.errors);
+                }
+            }
+        }
+        return this.makeRequest(`/shops/${shopId}`, {
+            method: 'PUT',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async createShopSection(shopId, params) {
+        return this.makeRequest(`/shops/${shopId}/sections`, {
+            method: 'POST',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async updateShopSection(shopId, sectionId, params) {
+        return this.makeRequest(`/shops/${shopId}/sections/${sectionId}`, {
+            method: 'PUT',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async deleteShopSection(shopId, sectionId) {
+        await this.makeRequest(`/shops/${shopId}/sections/${sectionId}`, { method: 'DELETE' }, false);
+    }
+    async createDraftListing(shopId, params, options) {
+        if (options?.validate) {
+            const schema = options.validateSchema || CreateListingSchema;
+            const throwOnError = options.throwOnValidationError !== false;
+            if (throwOnError) {
+                validateOrThrow(params, schema, 'Invalid listing parameters');
+            }
+            else {
+                const result = schema.validate(params);
+                if (!result.valid) {
+                    this.logger.warn('Listing validation failed', result.errors);
+                }
+            }
+        }
+        return this.makeRequest(`/shops/${shopId}/listings`, {
+            method: 'POST',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async updateListing(shopId, listingId, params, options) {
+        if (options?.validate) {
+            const schema = options.validateSchema || UpdateListingSchema;
+            const throwOnError = options.throwOnValidationError !== false;
+            if (throwOnError) {
+                validateOrThrow(params, schema, 'Invalid listing update parameters');
+            }
+            else {
+                const result = schema.validate(params);
+                if (!result.valid) {
+                    this.logger.warn('Listing update validation failed', result.errors);
+                }
+            }
+        }
+        return this.makeRequest(`/shops/${shopId}/listings/${listingId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async deleteListing(listingId) {
+        await this.makeRequest(`/listings/${listingId}`, { method: 'DELETE' }, false);
+    }
+    async updateListingInventory(listingId, params) {
+        return this.makeRequest(`/listings/${listingId}/inventory`, {
+            method: 'PUT',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async uploadListingImage(shopId, listingId, imageData, params) {
+        const formData = new FormData();
+        formData.append('image', imageData);
+        if (params?.rank !== undefined)
+            formData.append('rank', params.rank.toString());
+        if (params?.overwrite !== undefined)
+            formData.append('overwrite', params.overwrite.toString());
+        if (params?.is_watermarked !== undefined)
+            formData.append('is_watermarked', params.is_watermarked.toString());
+        if (params?.alt_text)
+            formData.append('alt_text', params.alt_text);
+        const url = `${this.baseUrl}/shops/${shopId}/listings/${listingId}/images`;
+        await this.rateLimiter.waitForRateLimit();
+        const accessToken = await this.tokenManager.getAccessToken();
+        const response = await this.fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'x-api-key': this.getApiKey(),
+            },
+            body: formData
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new EtsyApiError(`Failed to upload image: ${response.status} ${response.statusText}`, response.status, errorText);
+        }
+        return response.json();
+    }
+    async getListingImage(shopId, listingId, imageId) {
+        return this.makeRequest(`/shops/${shopId}/listings/${listingId}/images/${imageId}`);
+    }
+    async deleteListingImage(shopId, listingId, imageId) {
+        await this.makeRequest(`/shops/${shopId}/listings/${listingId}/images/${imageId}`, { method: 'DELETE' }, false);
+    }
+    async bulkUpdateListings(shopId, operations, config) {
+        const manager = config ? new BulkOperationManager(config) : this.bulkOperationManager;
+        return manager.executeBulk(operations, async (operation) => {
+            return this.updateListing(shopId, operation.listingId.toString(), operation.updates);
+        }, (operation) => operation.listingId);
+    }
+    async bulkUploadImages(shopId, listingId, images, config) {
+        const manager = config ? new BulkOperationManager(config) : this.bulkOperationManager;
+        return manager.executeBulk(images, async (image) => {
+            return this.uploadListingImage(shopId, listingId, image.file, {
+                rank: image.rank,
+                alt_text: image.altText
+            });
+        });
+    }
+    setBulkOperationConcurrency(concurrency) {
+        this.bulkOperationManager.setConcurrency(Math.max(1, Math.min(10, concurrency)));
+    }
+    async getShopReceipts(shopId, params) {
+        const searchParams = new URLSearchParams();
+        if (params?.limit !== undefined)
+            searchParams.set('limit', params.limit.toString());
+        if (params?.offset !== undefined)
+            searchParams.set('offset', params.offset.toString());
+        if (params?.sort_on)
+            searchParams.set('sort_on', params.sort_on);
+        if (params?.sort_order)
+            searchParams.set('sort_order', params.sort_order);
+        if (params?.min_created !== undefined)
+            searchParams.set('min_created', params.min_created.toString());
+        if (params?.max_created !== undefined)
+            searchParams.set('max_created', params.max_created.toString());
+        if (params?.min_last_modified !== undefined)
+            searchParams.set('min_last_modified', params.min_last_modified.toString());
+        if (params?.max_last_modified !== undefined)
+            searchParams.set('max_last_modified', params.max_last_modified.toString());
+        if (params?.was_paid !== undefined)
+            searchParams.set('was_paid', params.was_paid.toString());
+        if (params?.was_shipped !== undefined)
+            searchParams.set('was_shipped', params.was_shipped.toString());
+        if (params?.was_delivered !== undefined)
+            searchParams.set('was_delivered', params.was_delivered.toString());
+        const response = await this.makeRequest(`/shops/${shopId}/receipts?${searchParams.toString()}`);
+        return response.results;
+    }
+    async getShopReceipt(shopId, receiptId) {
+        return this.makeRequest(`/shops/${shopId}/receipts/${receiptId}`);
+    }
+    async updateShopReceipt(shopId, receiptId, params) {
+        return this.makeRequest(`/shops/${shopId}/receipts/${receiptId}`, {
+            method: 'PUT',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async getShopReceiptTransactions(shopId, receiptId) {
+        const response = await this.makeRequest(`/shops/${shopId}/receipts/${receiptId}/transactions`);
+        return response.results;
+    }
+    async getShopTransaction(shopId, transactionId) {
+        return this.makeRequest(`/shops/${shopId}/transactions/${transactionId}`);
+    }
+    async getShopShippingProfiles(shopId) {
+        const response = await this.makeRequest(`/shops/${shopId}/shipping-profiles`);
+        return response.results;
+    }
+    async createShopShippingProfile(shopId, params) {
+        return this.makeRequest(`/shops/${shopId}/shipping-profiles`, {
+            method: 'POST',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async getShopShippingProfile(shopId, profileId) {
+        return this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}`);
+    }
+    async updateShopShippingProfile(shopId, profileId, params) {
+        return this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}`, {
+            method: 'PUT',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async deleteShopShippingProfile(shopId, profileId) {
+        await this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}`, { method: 'DELETE' }, false);
+    }
+    async getShopShippingProfileDestinations(shopId, profileId) {
+        const response = await this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}/destinations`);
+        return response.results;
+    }
+    async createShopShippingProfileDestination(shopId, profileId, params) {
+        return this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}/destinations`, {
+            method: 'POST',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async updateShopShippingProfileDestination(shopId, profileId, destinationId, params) {
+        return this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}/destinations/${destinationId}`, {
+            method: 'PUT',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async deleteShopShippingProfileDestination(shopId, profileId, destinationId) {
+        await this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}/destinations/${destinationId}`, { method: 'DELETE' }, false);
+    }
+    async getShopShippingProfileUpgrades(shopId, profileId) {
+        const response = await this.makeRequest(`/shops/${shopId}/shipping-profiles/${profileId}/upgrades`);
+        return response.results;
+    }
+    async createReceiptShipment(shopId, receiptId, params) {
+        return this.makeRequest(`/shops/${shopId}/receipts/${receiptId}/tracking`, {
+            method: 'POST',
+            body: JSON.stringify(params)
+        }, false);
+    }
+    async getShopReceiptShipments(shopId, receiptId) {
+        const response = await this.makeRequest(`/shops/${shopId}/receipts/${receiptId}/shipments`);
+        return response.results;
+    }
+    async getShopPaymentAccountLedgerEntries(shopId, params) {
+        const searchParams = new URLSearchParams();
+        searchParams.set('min_created', params.min_created.toString());
+        searchParams.set('max_created', params.max_created.toString());
+        if (params.limit !== undefined)
+            searchParams.set('limit', params.limit.toString());
+        if (params.offset !== undefined)
+            searchParams.set('offset', params.offset.toString());
+        const response = await this.makeRequest(`/shops/${shopId}/payment-account/ledger-entries?${searchParams.toString()}`);
+        return response.results;
+    }
+    async getShopPaymentAccountLedgerEntry(shopId, entryId) {
+        return this.makeRequest(`/shops/${shopId}/payment-account/ledger-entries/${entryId}`);
+    }
+    async getShopPayment(shopId, paymentId) {
+        return this.makeRequest(`/shops/${shopId}/payment-account/payments/${paymentId}`);
+    }
+    async getBuyerTaxonomyNodes() {
+        const response = await this.makeRequest('/buyer-taxonomy/nodes');
+        return response.results;
+    }
+    async getPropertiesByTaxonomyId(taxonomyId) {
+        const response = await this.makeRequest(`/seller-taxonomy/nodes/${taxonomyId}/properties`);
+        return response.results;
+    }
+    async getListingProperties(shopId, listingId) {
+        const response = await this.makeRequest(`/shops/${shopId}/listings/${listingId}/properties`);
+        return response.results;
+    }
+    async getShopProductionPartners(shopId) {
+        const response = await this.makeRequest(`/shops/${shopId}/production-partners`);
+        return response.results;
+    }
     getRemainingRequests() {
         return this.rateLimiter.getRemainingRequests();
     }
@@ -917,6 +1734,1075 @@ const COMMON_SCOPE_COMBINATIONS = {
     ]
 };
 
+class PaginatedResults {
+    constructor(fetcher, options = {}) {
+        this.currentPage = [];
+        this.totalCount = null;
+        this.hasMore = true;
+        this.fetcher = fetcher;
+        this.options = {
+            limit: options.limit || 25,
+            offset: options.offset || 0,
+            maxPages: options.maxPages || Infinity,
+            maxItems: options.maxItems || Infinity
+        };
+        this.currentOffset = this.options.offset;
+    }
+    async *[Symbol.asyncIterator]() {
+        let pageCount = 0;
+        let itemCount = 0;
+        while (this.hasMore && pageCount < this.options.maxPages && itemCount < this.options.maxItems) {
+            const page = await this.fetchPage();
+            pageCount++;
+            for (const item of page) {
+                if (itemCount >= this.options.maxItems) {
+                    return;
+                }
+                yield item;
+                itemCount++;
+            }
+            if (!this.hasMore) {
+                break;
+            }
+        }
+    }
+    async getAll() {
+        const items = [];
+        for await (const item of this) {
+            items.push(item);
+        }
+        return items;
+    }
+    getCurrentPage() {
+        return this.currentPage;
+    }
+    hasNextPage() {
+        return this.hasMore;
+    }
+    async getNextPage() {
+        if (!this.hasMore) {
+            return [];
+        }
+        return this.fetchPage();
+    }
+    getTotalCount() {
+        return this.totalCount;
+    }
+    reset() {
+        this.currentOffset = this.options.offset;
+        this.currentPage = [];
+        this.totalCount = null;
+        this.hasMore = true;
+    }
+    async fetchPage() {
+        const response = await this.fetcher(this.options.limit, this.currentOffset);
+        this.currentPage = response.results;
+        this.totalCount = response.count;
+        if (response.pagination) {
+            if (response.pagination.next_offset !== undefined) {
+                this.hasMore = true;
+                this.currentOffset = response.pagination.next_offset;
+            }
+            else {
+                this.hasMore = false;
+            }
+        }
+        else {
+            this.hasMore = response.results.length === this.options.limit;
+            this.currentOffset += this.options.limit;
+        }
+        return this.currentPage;
+    }
+}
+function createPaginatedResults(fetcher, options) {
+    return new PaginatedResults(fetcher, options);
+}
+
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    retryDelay: 1000,
+    exponentialBackoff: true,
+    retryableStatusCodes: [429, 500, 502, 503, 504],
+    maxRetryDelay: 30000,
+    jitter: 0.1
+};
+function calculateDelay(attempt, config) {
+    let delay;
+    if (config.exponentialBackoff) {
+        delay = config.retryDelay * Math.pow(2, attempt - 1);
+    }
+    else {
+        delay = config.retryDelay * attempt;
+    }
+    if (config.maxRetryDelay) {
+        delay = Math.min(delay, config.maxRetryDelay);
+    }
+    if (config.jitter && config.jitter > 0) {
+        const jitterAmount = delay * config.jitter;
+        const randomJitter = Math.random() * jitterAmount * 2 - jitterAmount;
+        delay += randomJitter;
+    }
+    return Math.max(0, Math.floor(delay));
+}
+function isRetryableError(error, config) {
+    if (error instanceof EtsyApiError) {
+        const statusCode = error.statusCode;
+        if (statusCode && config.retryableStatusCodes.includes(statusCode)) {
+            return true;
+        }
+    }
+    if (error instanceof TypeError && error.message.includes('fetch')) {
+        return true;
+    }
+    return false;
+}
+function getRetryAfterDelay(error) {
+    if (error instanceof EtsyApiError && error.statusCode === 429) {
+        const retryAfter = error.getRetryAfter();
+        if (typeof retryAfter === 'number') {
+            return retryAfter * 1000;
+        }
+    }
+    return null;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function withRetry(operation, options = {}) {
+    const config = {
+        ...DEFAULT_RETRY_CONFIG,
+        ...options
+    };
+    let lastError = new Error('Unknown error');
+    let attempt = 0;
+    while (attempt <= config.maxRetries) {
+        try {
+            if (options.signal?.aborted) {
+                throw new Error('Operation aborted');
+            }
+            const result = await operation();
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            attempt++;
+            if (attempt > config.maxRetries) {
+                throw lastError;
+            }
+            if (!isRetryableError(error, config)) {
+                throw lastError;
+            }
+            let delay = calculateDelay(attempt, config);
+            const retryAfterDelay = getRetryAfterDelay(error);
+            if (retryAfterDelay !== null) {
+                delay = retryAfterDelay;
+            }
+            if (config.onRetry) {
+                config.onRetry(attempt, lastError);
+            }
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+class RetryManager {
+    constructor(config = {}) {
+        this.config = {
+            ...DEFAULT_RETRY_CONFIG,
+            ...config
+        };
+    }
+    async execute(operation, options) {
+        return withRetry(operation, {
+            ...this.config,
+            ...options
+        });
+    }
+    updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}
+
+class EtsyWebhookHandler {
+    constructor(config) {
+        this.config = {
+            algorithm: 'sha256',
+            verifySignatures: true,
+            ...config
+        };
+        this.handlers = new Map();
+        if (isNode$1) {
+            try {
+                this.crypto = require('crypto');
+            }
+            catch {
+                console.warn('crypto module not available, signature verification will not work');
+            }
+        }
+    }
+    verifySignature(payload, signature) {
+        if (!this.config.verifySignatures) {
+            return true;
+        }
+        if (!this.crypto) {
+            throw new Error('Signature verification requires Node.js crypto module');
+        }
+        try {
+            const hmac = this.crypto
+                .createHmac(this.config.algorithm, this.config.secret)
+                .update(payload)
+                .digest('hex');
+            return this.timingSafeEqual(hmac, signature);
+        }
+        catch (error) {
+            console.error('Signature verification failed:', error);
+            return false;
+        }
+    }
+    parseEvent(payload) {
+        const data = typeof payload === 'string' ? JSON.parse(payload) : payload;
+        if (!data.type || !data.data) {
+            throw new Error('Invalid webhook event format');
+        }
+        const event = {
+            type: data.type,
+            timestamp: data.timestamp || Date.now(),
+            data: data.data,
+            shop_id: data.shop_id,
+            user_id: data.user_id
+        };
+        this.triggerHandlers(event);
+        return event;
+    }
+    on(eventType, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, new Set());
+        }
+        const handlers = this.handlers.get(eventType);
+        if (handlers) {
+            handlers.add(handler);
+        }
+    }
+    off(eventType, handler) {
+        const handlers = this.handlers.get(eventType);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    removeAllListeners(eventType) {
+        if (eventType) {
+            this.handlers.delete(eventType);
+        }
+        else {
+            this.handlers.clear();
+        }
+    }
+    async triggerHandlers(event) {
+        const handlers = this.handlers.get(event.type);
+        if (!handlers || handlers.size === 0) {
+            return;
+        }
+        const promises = Array.from(handlers).map(handler => {
+            try {
+                return Promise.resolve(handler(event.data));
+            }
+            catch (error) {
+                console.error(`Error in webhook handler for ${event.type}:`, error);
+                return Promise.resolve();
+            }
+        });
+        await Promise.all(promises);
+    }
+    timingSafeEqual(a, b) {
+        if (this.crypto?.timingSafeEqual) {
+            const bufA = Buffer.from(a);
+            const bufB = Buffer.from(b);
+            if (bufA.length !== bufB.length) {
+                return false;
+            }
+            return this.crypto.timingSafeEqual(bufA, bufB);
+        }
+        else {
+            return a === b;
+        }
+    }
+    getHandlerCount(eventType) {
+        return this.handlers.get(eventType)?.size || 0;
+    }
+    getRegisteredEventTypes() {
+        return Array.from(this.handlers.keys());
+    }
+}
+function createWebhookHandler(config) {
+    return new EtsyWebhookHandler(config);
+}
+
+class LRUCache {
+    constructor(config = {}) {
+        this.cache = new Map();
+        this.currentSize = 0;
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0
+        };
+        this.maxSize = config.maxSize ?? 10485760;
+        this.maxEntries = config.maxEntries ?? 1000;
+        this.ttl = (config.ttl ?? 3600) * 1000;
+        this.trackStats = config.trackStats ?? true;
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            if (this.trackStats)
+                this.stats.misses++;
+            return null;
+        }
+        if (Date.now() > entry.expires) {
+            this.cache.delete(key);
+            this.currentSize -= entry.size;
+            if (this.trackStats)
+                this.stats.misses++;
+            return null;
+        }
+        entry.lastAccessed = Date.now();
+        entry.accessCount++;
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        if (this.trackStats)
+            this.stats.hits++;
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        const size = this.estimateSize(value);
+        const expiryTime = ttl ? ttl * 1000 : this.ttl;
+        const now = Date.now();
+        const existing = this.cache.get(key);
+        if (existing) {
+            this.currentSize -= existing.size;
+            this.cache.delete(key);
+        }
+        while ((this.currentSize + size > this.maxSize || this.cache.size >= this.maxEntries) &&
+            this.cache.size > 0) {
+            await this.evictLRU();
+        }
+        const entry = {
+            key,
+            value,
+            expires: now + expiryTime,
+            size,
+            accessCount: 0,
+            lastAccessed: now,
+            created: now
+        };
+        this.cache.set(key, entry);
+        this.currentSize += size;
+    }
+    async delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.cache.delete(key);
+            this.currentSize -= entry.size;
+        }
+    }
+    async clear() {
+        this.cache.clear();
+        this.currentSize = 0;
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+    }
+    async evictLRU() {
+        const firstKey = this.cache.keys().next().value;
+        if (firstKey) {
+            const entry = this.cache.get(firstKey);
+            if (entry) {
+                this.currentSize -= entry.size;
+            }
+            this.cache.delete(firstKey);
+            if (this.trackStats)
+                this.stats.evictions++;
+        }
+    }
+    estimateSize(str) {
+        return str.length * 2;
+    }
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            hitRate: total > 0 ? this.stats.hits / total : 0,
+            missRate: total > 0 ? this.stats.misses / total : 0,
+            size: this.currentSize,
+            entryCount: this.cache.size,
+            evictions: this.stats.evictions,
+            maxSize: this.maxSize,
+            maxEntries: this.maxEntries
+        };
+    }
+}
+class LFUCache {
+    constructor(config = {}) {
+        this.cache = new Map();
+        this.currentSize = 0;
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0
+        };
+        this.maxSize = config.maxSize ?? 10485760;
+        this.maxEntries = config.maxEntries ?? 1000;
+        this.ttl = (config.ttl ?? 3600) * 1000;
+        this.trackStats = config.trackStats ?? true;
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            if (this.trackStats)
+                this.stats.misses++;
+            return null;
+        }
+        if (Date.now() > entry.expires) {
+            this.cache.delete(key);
+            this.currentSize -= entry.size;
+            if (this.trackStats)
+                this.stats.misses++;
+            return null;
+        }
+        entry.accessCount++;
+        entry.lastAccessed = Date.now();
+        if (this.trackStats)
+            this.stats.hits++;
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        const size = this.estimateSize(value);
+        const expiryTime = ttl ? ttl * 1000 : this.ttl;
+        const now = Date.now();
+        const existing = this.cache.get(key);
+        if (existing) {
+            this.currentSize -= existing.size;
+            this.cache.delete(key);
+        }
+        while ((this.currentSize + size > this.maxSize || this.cache.size >= this.maxEntries) &&
+            this.cache.size > 0) {
+            await this.evictLFU();
+        }
+        const entry = {
+            key,
+            value,
+            expires: now + expiryTime,
+            size,
+            accessCount: 0,
+            lastAccessed: now,
+            created: now
+        };
+        this.cache.set(key, entry);
+        this.currentSize += size;
+    }
+    async delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.cache.delete(key);
+            this.currentSize -= entry.size;
+        }
+    }
+    async clear() {
+        this.cache.clear();
+        this.currentSize = 0;
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+    }
+    async evictLFU() {
+        let minAccessCount = Infinity;
+        let keyToEvict = null;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.accessCount < minAccessCount) {
+                minAccessCount = entry.accessCount;
+                keyToEvict = key;
+            }
+        }
+        if (keyToEvict) {
+            const entry = this.cache.get(keyToEvict);
+            if (entry) {
+                this.currentSize -= entry.size;
+            }
+            this.cache.delete(keyToEvict);
+            if (this.trackStats)
+                this.stats.evictions++;
+        }
+    }
+    estimateSize(str) {
+        return str.length * 2;
+    }
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            hitRate: total > 0 ? this.stats.hits / total : 0,
+            missRate: total > 0 ? this.stats.misses / total : 0,
+            size: this.currentSize,
+            entryCount: this.cache.size,
+            evictions: this.stats.evictions,
+            maxSize: this.maxSize,
+            maxEntries: this.maxEntries
+        };
+    }
+}
+class CacheWithInvalidation {
+    constructor(baseCache, config = {}) {
+        this.baseCache = baseCache;
+        this.invalidationPatterns = new Set(config.invalidateOn?.patterns || []);
+        this.mutationPatterns = new Map();
+        if (config.invalidateOn?.mutations !== false) {
+            this.mutationPatterns.set('shops/*/update', ['shops/*']);
+            this.mutationPatterns.set('listings/*/update', ['listings/*']);
+            this.mutationPatterns.set('receipts/*/update', ['receipts/*']);
+        }
+    }
+    async get(key) {
+        return this.baseCache.get(key);
+    }
+    async set(key, value, ttl) {
+        return this.baseCache.set(key, value, ttl);
+    }
+    async delete(key) {
+        return this.baseCache.delete(key);
+    }
+    async clear() {
+        return this.baseCache.clear();
+    }
+    async invalidatePattern(_pattern) {
+        await this.baseCache.clear();
+    }
+    async invalidateOnMutation(mutationType) {
+        const patterns = this.mutationPatterns.get(mutationType);
+        if (patterns) {
+            for (const pattern of patterns) {
+                await this.invalidatePattern(pattern);
+            }
+        }
+    }
+    addInvalidationPattern(pattern) {
+        this.invalidationPatterns.add(pattern);
+    }
+    removeInvalidationPattern(pattern) {
+        this.invalidationPatterns.delete(pattern);
+    }
+    addMutationPattern(mutationType, patterns) {
+        this.mutationPatterns.set(mutationType, patterns);
+    }
+}
+class RedisCacheStorage {
+    constructor(config, client) {
+        this.config = config;
+        this.keyPrefix = config.keyPrefix || 'etsy:';
+        if (!client) {
+            throw new Error('Redis client must be provided. Install a Redis client library (e.g., ioredis) and pass the client instance.');
+        }
+        this.client = client;
+    }
+    async get(key) {
+        try {
+            const value = await this.client.get(this.keyPrefix + key);
+            return value;
+        }
+        catch (error) {
+            console.error('Redis get error:', error);
+            return null;
+        }
+    }
+    async set(key, value, ttl = 3600) {
+        try {
+            await this.client.setex(this.keyPrefix + key, ttl, value);
+        }
+        catch (error) {
+            console.error('Redis set error:', error);
+        }
+    }
+    async delete(key) {
+        try {
+            await this.client.del(this.keyPrefix + key);
+        }
+        catch (error) {
+            console.error('Redis delete error:', error);
+        }
+    }
+    async clear() {
+        try {
+            const keys = await this.client.keys(this.keyPrefix + '*');
+            if (keys.length > 0) {
+                await this.client.del(...keys);
+            }
+        }
+        catch (error) {
+            console.error('Redis clear error:', error);
+        }
+    }
+    getClient() {
+        return this.client;
+    }
+}
+function createCacheStorage(config = {}) {
+    const strategy = config.strategy || 'lru';
+    switch (strategy) {
+        case 'lru':
+            return new LRUCache(config);
+        case 'lfu':
+            return new LFUCache(config);
+        case 'ttl':
+            return new LRUCache(config);
+        default:
+            return new LRUCache(config);
+    }
+}
+function createCacheWithInvalidation(baseCache, config = {}) {
+    return new CacheWithInvalidation(baseCache, config);
+}
+function createRedisCacheStorage(config, client) {
+    return new RedisCacheStorage(config, client);
+}
+
+class ListingQueryBuilder {
+    constructor(client, shopId) {
+        this.params = {};
+        this.includeFields = [];
+        this.client = client;
+        this.shopId = shopId;
+    }
+    where(filters) {
+        if (filters.state) {
+            this.params.state = filters.state;
+        }
+        return this;
+    }
+    include(fields) {
+        this.includeFields = fields;
+        this.params.includes = fields;
+        return this;
+    }
+    limit(limit) {
+        this.params.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.params.offset = offset;
+        return this;
+    }
+    sortBy(field, order = 'asc') {
+        this.params.sort_on = field;
+        this.params.sort_order = (order === 'asc' ? 'up' : 'down');
+        return this;
+    }
+    async fetch() {
+        if (!this.shopId) {
+            throw new Error('Shop ID is required for listing queries');
+        }
+        return this.client.getListingsByShop(this.shopId, this.params);
+    }
+    async first() {
+        this.params.limit = 1;
+        const results = await this.fetch();
+        return results[0] || null;
+    }
+    async count() {
+        const results = await this.fetch();
+        return results.length;
+    }
+}
+class ReceiptQueryBuilder {
+    constructor(client, shopId) {
+        this.params = {};
+        this.client = client;
+        this.shopId = shopId;
+    }
+    where(filters) {
+        Object.assign(this.params, filters);
+        return this;
+    }
+    limit(limit) {
+        this.params.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.params.offset = offset;
+        return this;
+    }
+    sortBy(field, order = 'desc') {
+        this.params.sort_on = field;
+        this.params.sort_order = (order === 'asc' ? 'up' : 'down');
+        return this;
+    }
+    async fetch() {
+        return this.client.getShopReceipts(this.shopId, this.params);
+    }
+    async first() {
+        this.params.limit = 1;
+        const results = await this.fetch();
+        return results[0] || null;
+    }
+}
+class BatchQueryExecutor {
+    constructor(client) {
+        this.operations = [];
+        this.client = client;
+    }
+    getShop(shopId) {
+        this.operations.push(() => this.client.getShop(shopId));
+        return this;
+    }
+    getListings(shopId, params) {
+        this.operations.push(() => this.client.getListingsByShop(shopId, params));
+        return this;
+    }
+    getReceipts(shopId, params) {
+        this.operations.push(() => this.client.getShopReceipts(shopId, params));
+        return this;
+    }
+    custom(operation) {
+        this.operations.push(operation);
+        return this;
+    }
+    async execute() {
+        return Promise.all(this.operations.map(op => op()));
+    }
+    async executeSequential() {
+        const results = [];
+        for (const operation of this.operations) {
+            results.push(await operation());
+        }
+        return results;
+    }
+    clear() {
+        this.operations = [];
+        return this;
+    }
+    size() {
+        return this.operations.length;
+    }
+}
+function withQueryBuilder(client) {
+    const extendedClient = client;
+    extendedClient.listings = function (shopId) {
+        return new ListingQueryBuilder(this, shopId);
+    };
+    extendedClient.receipts = function (shopId) {
+        return new ReceiptQueryBuilder(this, shopId);
+    };
+    extendedClient.batch = function () {
+        return new BatchQueryExecutor(this);
+    };
+    return extendedClient;
+}
+function createListingQuery(client, shopId) {
+    return new ListingQueryBuilder(client, shopId);
+}
+function createReceiptQuery(client, shopId) {
+    return new ReceiptQueryBuilder(client, shopId);
+}
+function createBatchQuery(client) {
+    return new BatchQueryExecutor(client);
+}
+
+async function encryptAES256GCM(data, key) {
+    if (!isNode$1) {
+        throw new Error('AES-256-GCM encryption is only available in Node.js environments');
+    }
+    const crypto = await import('crypto');
+    const keyBuffer = Buffer.isBuffer(key) ? key : Buffer.from(key, 'utf8');
+    if (keyBuffer.length !== 32) {
+        throw new Error('Encryption key must be exactly 32 bytes for AES-256');
+    }
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', keyBuffer, iv);
+    const encrypted = Buffer.concat([
+        cipher.update(data, 'utf8'),
+        cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+        ciphertext: encrypted.toString('base64'),
+        iv: iv.toString('base64'),
+        authTag: authTag.toString('base64'),
+        algorithm: 'aes-256-gcm'
+    };
+}
+async function decryptAES256GCM(encryptedData, key) {
+    if (!isNode$1) {
+        throw new Error('AES-256-GCM decryption is only available in Node.js environments');
+    }
+    const crypto = await import('crypto');
+    const keyBuffer = Buffer.isBuffer(key) ? key : Buffer.from(key, 'utf8');
+    if (keyBuffer.length !== 32) {
+        throw new Error('Decryption key must be exactly 32 bytes for AES-256');
+    }
+    if (encryptedData.algorithm !== 'aes-256-gcm') {
+        throw new Error(`Unsupported encryption algorithm: ${encryptedData.algorithm}`);
+    }
+    const iv = Buffer.from(encryptedData.iv, 'base64');
+    const authTag = Buffer.from(encryptedData.authTag, 'base64');
+    const ciphertext = Buffer.from(encryptedData.ciphertext, 'base64');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', keyBuffer, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final()
+    ]);
+    return decrypted.toString('utf8');
+}
+async function generateEncryptionKey(length = 32) {
+    if (!isNode$1) {
+        throw new Error('Key generation is only available in Node.js environments');
+    }
+    const crypto = await import('crypto');
+    return crypto.randomBytes(length);
+}
+async function deriveKeyFromPassword(password, salt, iterations = 100000, keyLength = 32) {
+    if (!isNode$1) {
+        throw new Error('Key derivation is only available in Node.js environments');
+    }
+    const crypto = await import('crypto');
+    const saltBuffer = Buffer.isBuffer(salt) ? salt : Buffer.from(salt, 'utf8');
+    return new Promise((resolve, reject) => {
+        crypto.pbkdf2(password, saltBuffer, iterations, keyLength, 'sha256', (err, derivedKey) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(derivedKey);
+            }
+        });
+    });
+}
+function validateEncryptionKey(key, requiredLength = 32) {
+    const keyBuffer = Buffer.isBuffer(key) ? key : Buffer.from(key, 'utf8');
+    if (keyBuffer.length !== requiredLength) {
+        throw new Error(`Invalid encryption key length: expected ${requiredLength} bytes, got ${keyBuffer.length} bytes`);
+    }
+    return true;
+}
+
+class EncryptedFileTokenStorage {
+    constructor(config) {
+        if (!isNode$1) {
+            throw new Error('EncryptedFileTokenStorage is only available in Node.js environments');
+        }
+        this.filePath = config.filePath;
+        this.fileMode = config.fileMode ?? 0o600;
+        const keyBuffer = Buffer.isBuffer(config.encryptionKey)
+            ? config.encryptionKey
+            : Buffer.from(config.encryptionKey, 'utf8');
+        validateEncryptionKey(keyBuffer, 32);
+        this.encryptionKey = keyBuffer;
+    }
+    async save(tokens) {
+        if (!isNode$1) {
+            throw new Error('EncryptedFileTokenStorage is only available in Node.js');
+        }
+        try {
+            const tokenData = JSON.stringify(tokens);
+            const encrypted = await encryptAES256GCM(tokenData, this.encryptionKey);
+            const fileData = {
+                version: 1,
+                encrypted,
+                timestamp: Date.now()
+            };
+            const fileContent = JSON.stringify(fileData, null, 2);
+            await this._writeFile(this.filePath, fileContent);
+            await this._setFilePermissions(this.filePath, this.fileMode);
+        }
+        catch (error) {
+            throw new Error(`Failed to save encrypted tokens: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async load() {
+        if (!isNode$1) {
+            return null;
+        }
+        try {
+            const fileContent = await this._readFile(this.filePath);
+            const fileData = JSON.parse(fileContent);
+            if (fileData.version !== 1) {
+                throw new Error(`Unsupported encrypted file format version: ${fileData.version}`);
+            }
+            const decryptedData = await decryptAES256GCM(fileData.encrypted, this.encryptionKey);
+            const tokens = JSON.parse(decryptedData);
+            if (tokens.expires_at) {
+                tokens.expires_at = new Date(tokens.expires_at);
+            }
+            return tokens;
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return null;
+            }
+            console.error('Failed to load encrypted tokens:', error instanceof Error ? error.message : 'Unknown error');
+            return null;
+        }
+    }
+    async clear() {
+        if (!isNode$1) {
+            return;
+        }
+        try {
+            await this._deleteFile(this.filePath);
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code !== 'ENOENT') {
+                console.error('Failed to clear encrypted tokens:', error instanceof Error ? error.message : 'Unknown error');
+            }
+        }
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+    async exists() {
+        if (!isNode$1) {
+            return false;
+        }
+        try {
+            await this._stat(this.filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async _writeFile(filePath, data) {
+        if (typeof process === 'undefined')
+            return;
+        const fs = await import('fs');
+        await fs.promises.writeFile(filePath, data, 'utf8');
+    }
+    async _setFilePermissions(filePath, mode) {
+        if (typeof process === 'undefined')
+            return;
+        try {
+            const fs = await import('fs');
+            await fs.promises.chmod(filePath, mode);
+        }
+        catch {
+        }
+    }
+    async _readFile(filePath) {
+        if (typeof process === 'undefined')
+            throw new Error('Not available');
+        const fs = await import('fs');
+        return await fs.promises.readFile(filePath, 'utf8');
+    }
+    async _deleteFile(filePath) {
+        if (typeof process === 'undefined')
+            return;
+        const fs = await import('fs');
+        await fs.promises.unlink(filePath);
+    }
+    async _stat(filePath) {
+        if (typeof process === 'undefined')
+            throw new Error('Not available');
+        const fs = await import('fs');
+        return await fs.promises.stat(filePath);
+    }
+}
+
+class WebhookSecurity {
+    constructor(config) {
+        this.secret = config.secret;
+        this.algorithm = config.algorithm || 'sha256';
+        if (!this.secret) {
+            throw new Error('Webhook secret is required');
+        }
+        if (isNode$1) {
+            try {
+                this.crypto = require('crypto');
+            }
+            catch {
+                throw new Error('crypto module not available, webhook security requires Node.js');
+            }
+        }
+        else {
+            throw new Error('WebhookSecurity is only available in Node.js environments');
+        }
+    }
+    signRequest(payload, encoding = 'hex') {
+        if (!this.crypto) {
+            throw new Error('Crypto module not available');
+        }
+        const data = typeof payload === 'string' ? payload : JSON.stringify(payload);
+        const hmac = this.crypto
+            .createHmac(this.algorithm, this.secret)
+            .update(data)
+            .digest(encoding);
+        return hmac;
+    }
+    verifySignature(payload, signature, encoding = 'hex') {
+        if (!this.crypto) {
+            throw new Error('Crypto module not available');
+        }
+        try {
+            const expectedSignature = this.signRequest(payload, encoding);
+            return this.timingSafeEqual(expectedSignature, signature);
+        }
+        catch (error) {
+            console.error('Signature verification failed:', error);
+            return false;
+        }
+    }
+    signRequestWithTimestamp(payload, timestamp, encoding = 'hex') {
+        const ts = timestamp || Math.floor(Date.now() / 1000);
+        const data = typeof payload === 'string' ? payload : JSON.stringify(payload);
+        const signedPayload = `${ts}.${data}`;
+        const signature = this.signRequest(signedPayload, encoding);
+        return {
+            timestamp: ts,
+            signature
+        };
+    }
+    verifySignatureWithTimestamp(payload, signature, timestamp, maxAge = 300, encoding = 'hex') {
+        const now = Math.floor(Date.now() / 1000);
+        const age = now - timestamp;
+        if (age < 0) {
+            console.warn('Webhook timestamp is in the future');
+            return false;
+        }
+        if (age > maxAge) {
+            console.warn(`Webhook request is too old: ${age} seconds`);
+            return false;
+        }
+        const data = typeof payload === 'string' ? payload : JSON.stringify(payload);
+        const signedPayload = `${timestamp}.${data}`;
+        return this.verifySignature(signedPayload, signature, encoding);
+    }
+    timingSafeEqual(a, b) {
+        if (!this.crypto?.timingSafeEqual) {
+            console.warn('crypto.timingSafeEqual not available, using simple comparison');
+            return a === b;
+        }
+        const bufA = Buffer.from(a);
+        const bufB = Buffer.from(b);
+        if (bufA.length !== bufB.length) {
+            return false;
+        }
+        return this.crypto.timingSafeEqual(bufA, bufB);
+    }
+    getAlgorithm() {
+        return this.algorithm;
+    }
+    updateSecret(newSecret) {
+        if (!newSecret) {
+            throw new Error('Secret cannot be empty');
+        }
+        this.secret = newSecret;
+    }
+}
+function createWebhookSecurity(secret, algorithm = 'sha256') {
+    return new WebhookSecurity({ secret, algorithm });
+}
+
 function createEtsyClient(config) {
     return new EtsyClient(config);
 }
@@ -929,43 +2815,81 @@ function createTokenManager(config, storage) {
 function createRateLimiter(config) {
     return new EtsyRateLimiter(config);
 }
-const VERSION = '1.0.0';
+const VERSION = '2.2.0';
 const LIBRARY_NAME = 'etsy-v3-api-client';
 function getLibraryInfo() {
     return {
         name: LIBRARY_NAME,
         version: VERSION,
         description: 'JavaScript/TypeScript client for the Etsy Open API v3 with OAuth 2.0 authentication',
-        author: 'Henry',
+        author: 'profplum700',
         license: 'MIT',
         homepage: 'https://github.com/ForestHillArtsHouse/etsy-v3-api-client#readme'
     };
 }
 
 exports.AuthHelper = AuthHelper;
+exports.BatchQueryExecutor = BatchQueryExecutor;
+exports.BulkOperationManager = BulkOperationManager;
 exports.COMMON_SCOPE_COMBINATIONS = COMMON_SCOPE_COMBINATIONS;
+exports.CacheWithInvalidation = CacheWithInvalidation;
+exports.CreateListingSchema = CreateListingSchema;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
 exports.ETSY_SCOPES = ETSY_SCOPES;
+exports.EncryptedFileTokenStorage = EncryptedFileTokenStorage;
 exports.EtsyApiError = EtsyApiError;
 exports.EtsyAuthError = EtsyAuthError;
 exports.EtsyClient = EtsyClient;
 exports.EtsyRateLimitError = EtsyRateLimitError;
 exports.EtsyRateLimiter = EtsyRateLimiter;
+exports.EtsyWebhookHandler = EtsyWebhookHandler;
+exports.FieldValidator = FieldValidator;
 exports.FileTokenStorage = FileTokenStorage;
+exports.LFUCache = LFUCache;
 exports.LIBRARY_NAME = LIBRARY_NAME;
+exports.LRUCache = LRUCache;
+exports.ListingQueryBuilder = ListingQueryBuilder;
 exports.LocalStorageTokenStorage = LocalStorageTokenStorage;
 exports.MemoryTokenStorage = MemoryTokenStorage;
+exports.PaginatedResults = PaginatedResults;
+exports.ReceiptQueryBuilder = ReceiptQueryBuilder;
+exports.RedisCacheStorage = RedisCacheStorage;
+exports.RetryManager = RetryManager;
 exports.SessionStorageTokenStorage = SessionStorageTokenStorage;
 exports.TokenManager = TokenManager;
+exports.UpdateListingSchema = UpdateListingSchema;
+exports.UpdateShopSchema = UpdateShopSchema;
 exports.VERSION = VERSION;
+exports.ValidationException = ValidationException;
+exports.Validator = Validator;
+exports.WebhookSecurity = WebhookSecurity;
+exports.combineValidators = combineValidators;
 exports.createAuthHelper = createAuthHelper;
+exports.createBatchQuery = createBatchQuery;
+exports.createBulkOperationManager = createBulkOperationManager;
+exports.createCacheStorage = createCacheStorage;
+exports.createCacheWithInvalidation = createCacheWithInvalidation;
 exports.createCodeChallenge = createCodeChallenge;
 exports.createDefaultTokenStorage = createDefaultTokenStorage;
 exports.createEtsyClient = createEtsyClient;
+exports.createListingQuery = createListingQuery;
+exports.createPaginatedResults = createPaginatedResults;
 exports.createRateLimiter = createRateLimiter;
+exports.createReceiptQuery = createReceiptQuery;
+exports.createRedisCacheStorage = createRedisCacheStorage;
 exports.createTokenManager = createTokenManager;
+exports.createValidator = createValidator;
+exports.createWebhookHandler = createWebhookHandler;
+exports.createWebhookSecurity = createWebhookSecurity;
+exports.decryptAES256GCM = decryptAES256GCM;
 exports.default = EtsyClient;
 exports.defaultRateLimiter = defaultRateLimiter;
+exports.deriveKeyFromPassword = deriveKeyFromPassword;
+exports.encryptAES256GCM = encryptAES256GCM;
+exports.executeBulkOperation = executeBulkOperation;
+exports.field = field;
 exports.generateCodeVerifier = generateCodeVerifier;
+exports.generateEncryptionKey = generateEncryptionKey;
 exports.generateRandomBase64Url = generateRandomBase64Url;
 exports.generateState = generateState;
 exports.getAvailableStorage = getAvailableStorage;
@@ -977,4 +2901,9 @@ exports.isBrowser = isBrowser$1;
 exports.isNode = isNode$1;
 exports.sha256 = sha256;
 exports.sha256Base64Url = sha256Base64Url;
+exports.validate = validate;
+exports.validateEncryptionKey = validateEncryptionKey;
+exports.validateOrThrow = validateOrThrow;
+exports.withQueryBuilder = withQueryBuilder;
+exports.withRetry = withRetry;
 //# sourceMappingURL=node.cjs.map