@profplum700/etsy-v3-api-client 1.0.2 → 2.3.5

package/dist/node.esm.js

@@ -1,9 +1,38 @@
 class EtsyApiError extends Error {
-    constructor(message, _statusCode, _response) {
+    constructor(message, _statusCode, _response, _retryAfter, endpoint) {
         super(message);
         this._statusCode = _statusCode;
         this._response = _response;
+        this._retryAfter = _retryAfter;
         this.name = 'EtsyApiError';
+        this.endpoint = endpoint;
+        this.timestamp = new Date();
+        this.details = {
+            statusCode: _statusCode || 0,
+            retryAfter: _retryAfter,
+            endpoint,
+            timestamp: this.timestamp
+        };
+        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);
+            if (Array.isArray(resp.errors)) {
+                this.details.validationErrors = resp.errors.map((err) => {
+                    if (err && typeof err === 'object') {
+                        const e = err;
+                        return {
+                            field: String(e.field || 'unknown'),
+                            message: String(e.message || 'Validation error')
+                        };
+                    }
+                    return { field: 'unknown', message: String(err) };
+                });
+            }
+        }
+        this.suggestions = this.generateSuggestions();
+        this.docsUrl = this.generateDocsUrl();
     }
     get statusCode() {
         return this._statusCode;
@@ -11,6 +40,188 @@ 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);
+    }
+    generateSuggestions() {
+        const suggestions = [];
+        if (!this._statusCode) {
+            return ['Check your network connection and try again'];
+        }
+        switch (this._statusCode) {
+            case 400:
+                suggestions.push('Review the Etsy API documentation for this endpoint');
+                suggestions.push('Check all required parameters are provided');
+                suggestions.push('Validate parameter formats and types');
+                if (this.details.validationErrors && this.details.validationErrors.length > 0) {
+                    suggestions.push('\nValidation errors:');
+                    this.details.validationErrors.forEach(err => {
+                        suggestions.push(`  • ${err.field}: ${err.message}`);
+                    });
+                }
+                if (this.details.field) {
+                    suggestions.push(`Field causing issue: ${this.details.field}`);
+                }
+                break;
+            case 401:
+                suggestions.push('Verify your access token is valid and not expired');
+                suggestions.push('Check if you need to refresh the token');
+                suggestions.push('Ensure you completed the OAuth flow correctly');
+                if (this.endpoint?.includes('/shops/')) {
+                    suggestions.push('Verify the shop_id matches the authenticated user');
+                }
+                break;
+            case 403:
+                suggestions.push('Check if your OAuth app has the required scopes:');
+                if (this.endpoint?.includes('/listings')) {
+                    suggestions.push('  • listings_r (for reading listings)');
+                    suggestions.push('  • listings_w (for creating/updating listings)');
+                }
+                if (this.endpoint?.includes('/receipts') || this.endpoint?.includes('/transactions')) {
+                    suggestions.push('  • transactions_r (for reading orders)');
+                }
+                if (this.endpoint?.includes('/shops')) {
+                    suggestions.push('  • shops_r (for reading shop data)');
+                    suggestions.push('  • shops_w (for updating shop data)');
+                }
+                suggestions.push('Verify your app is approved for production access');
+                suggestions.push('Check if the resource belongs to the authenticated user');
+                break;
+            case 404:
+                suggestions.push('Verify the resource ID exists and is spelled correctly');
+                if (this.endpoint?.includes('/listings/')) {
+                    suggestions.push('Check if the listing is active and not deleted');
+                    suggestions.push('Ensure the listing belongs to the authenticated shop');
+                }
+                if (this.endpoint?.includes('/shops/')) {
+                    suggestions.push('Verify the shop ID is correct');
+                }
+                if (this.endpoint?.includes('/receipts/')) {
+                    suggestions.push('Check if the receipt ID is valid');
+                    suggestions.push('Ensure you have access to this shop\'s receipts');
+                }
+                break;
+            case 409:
+                suggestions.push('Resource state conflict detected');
+                suggestions.push('Check if the resource was modified by another process');
+                suggestions.push('Try fetching the latest resource state before updating');
+                break;
+            case 429: {
+                const resetTime = this.getRateLimitReset();
+                const resetTimeStr = resetTime
+                    ? resetTime.toLocaleTimeString()
+                    : 'shortly';
+                suggestions.push(`Rate limit exceeded. Resets at ${resetTimeStr}`);
+                suggestions.push('Implement exponential backoff retry logic');
+                suggestions.push('Consider caching responses to reduce API calls');
+                suggestions.push('Check if you can batch multiple operations');
+                if (this._retryAfter) {
+                    suggestions.push(`Wait ${this._retryAfter} seconds before retrying`);
+                }
+                break;
+            }
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                suggestions.push('This is an Etsy server error, not your code');
+                suggestions.push('Retry the request after a short delay (exponential backoff)');
+                suggestions.push('Check Etsy API status: https://status.etsy.com');
+                if (this.isRetryable()) {
+                    suggestions.push('This error is retryable - the request can be safely retried');
+                }
+                break;
+            default:
+                suggestions.push('Check the Etsy API documentation for this endpoint');
+                suggestions.push('Review your request parameters and format');
+                if (this.details.suggestion) {
+                    suggestions.push(`Etsy suggestion: ${this.details.suggestion}`);
+                }
+        }
+        return suggestions;
+    }
+    generateDocsUrl() {
+        const errorCode = this.details.errorCode?.toLowerCase() || this._statusCode?.toString() || 'unknown';
+        return `https://github.com/profplum700/etsy-v3-api-client/blob/main/docs/troubleshooting/ERROR_CODES.md#${errorCode}`;
+    }
+    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;
+    }
+    toString() {
+        const parts = [
+            `EtsyApiError: ${this.message}`,
+            `Status Code: ${this._statusCode || 'Unknown'}`,
+        ];
+        if (this.details.errorCode) {
+            parts.push(`Error Code: ${this.details.errorCode}`);
+        }
+        if (this.endpoint) {
+            parts.push(`Endpoint: ${this.endpoint}`);
+        }
+        parts.push(`Timestamp: ${this.timestamp.toISOString()}`);
+        if (this.suggestions.length > 0) {
+            parts.push('\nSuggestions:');
+            this.suggestions.forEach(s => {
+                if (!s.startsWith('  •')) {
+                    parts.push(`  • ${s}`);
+                }
+                else {
+                    parts.push(s);
+                }
+            });
+        }
+        parts.push(`\nDocumentation: ${this.docsUrl}`);
+        return parts.join('\n');
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this._statusCode,
+            errorCode: this.details.errorCode,
+            endpoint: this.endpoint,
+            suggestions: this.suggestions,
+            docsUrl: this.docsUrl,
+            timestamp: this.timestamp.toISOString(),
+            details: this.details,
+            isRetryable: this.isRetryable(),
+        };
+    }
 }
 class EtsyAuthError extends Error {
     constructor(message, _code) {
@@ -102,11 +313,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,
@@ -114,6 +326,9 @@ class TokenManager {
             token_type: 'Bearer',
             scope: ''
         };
+        if (this.rotationConfig?.enabled && this.rotationConfig?.autoSchedule) {
+            this.startRotationScheduler();
+        }
     }
     async getAccessToken() {
         if (!this.currentTokens) {
@@ -174,8 +389,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 {
@@ -230,6 +444,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);
@@ -326,6 +607,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');
@@ -363,6 +645,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');
@@ -460,6 +752,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
@@ -524,6 +1217,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}`;
@@ -556,6 +1253,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);
@@ -674,6 +1378,270 @@ class EtsyClient {
         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();
     }
@@ -921,6 +1889,1640 @@ const COMMON_SCOPE_COMBINATIONS = {
     ]
 };
 
+class GlobalRequestQueue {
+    constructor() {
+        this.queue = [];
+        this.processing = false;
+        this.rateLimits = new Map();
+        this.requestCount = 0;
+        this.dailyReset = new Date();
+        this.lastRequestTime = 0;
+        this.maxRequestsPerDay = 10000;
+        this.maxRequestsPerSecond = 10;
+        this.minRequestInterval = 100;
+        this.setNextDailyReset();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new GlobalRequestQueue();
+        }
+        return this.instance;
+    }
+    static resetInstance() {
+        this.instance = null;
+    }
+    async enqueue(request, options = {}) {
+        return new Promise((resolve, reject) => {
+            const queuedRequest = {
+                id: this.generateId(),
+                request,
+                resolve: resolve,
+                reject,
+                priority: options.priority ?? 'normal',
+                addedAt: Date.now(),
+                timeout: options.timeout ?? 30000,
+                endpoint: options.endpoint,
+            };
+            this.queue.push(queuedRequest);
+            if (!this.processing) {
+                this.processQueue().catch(error => {
+                    console.error('Queue processing error:', error);
+                });
+            }
+        });
+    }
+    getStatus() {
+        return {
+            queueLength: this.queue.length,
+            processing: this.processing,
+            remainingRequests: Math.max(0, this.maxRequestsPerDay - this.requestCount),
+            resetTime: this.dailyReset,
+        };
+    }
+    clear() {
+        this.queue.forEach(item => {
+            item.reject(new Error('Queue cleared'));
+        });
+        this.queue = [];
+    }
+    async processQueue() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (this.queue.length > 0) {
+                if (Date.now() >= this.dailyReset.getTime()) {
+                    this.requestCount = 0;
+                    this.setNextDailyReset();
+                }
+                if (this.requestCount >= this.maxRequestsPerDay) {
+                    const timeUntilReset = this.dailyReset.getTime() - Date.now();
+                    console.warn(`Daily rate limit reached. Waiting ${Math.ceil(timeUntilReset / 1000 / 60)} minutes until reset.`);
+                    await this.delay(timeUntilReset);
+                    this.requestCount = 0;
+                    this.setNextDailyReset();
+                }
+                await this.waitForRateLimit();
+                this.queue.sort((a, b) => {
+                    const priorityOrder = {
+                        high: 0,
+                        normal: 1,
+                        low: 2,
+                    };
+                    return priorityOrder[a.priority] - priorityOrder[b.priority];
+                });
+                const item = this.queue.shift();
+                if (!item) {
+                    break;
+                }
+                const elapsed = Date.now() - item.addedAt;
+                if (item.timeout && elapsed > item.timeout) {
+                    item.reject(new Error(`Request timeout after ${elapsed}ms (exceeded while waiting in queue)`));
+                    continue;
+                }
+                try {
+                    let result;
+                    if (item.timeout) {
+                        const remainingTimeout = item.timeout - elapsed;
+                        const timeoutPromise = new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new Error(`Request timeout after ${item.timeout}ms (exceeded during execution)`));
+                            }, remainingTimeout);
+                        });
+                        result = await Promise.race([item.request(), timeoutPromise]);
+                    }
+                    else {
+                        result = await item.request();
+                    }
+                    item.resolve(result);
+                    this.requestCount++;
+                    this.lastRequestTime = Date.now();
+                }
+                catch (error) {
+                    if (error instanceof EtsyRateLimitError) {
+                        this.updateRateLimitInfo(error);
+                    }
+                    item.reject(error);
+                }
+                await this.delay(this.minRequestInterval);
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    async waitForRateLimit() {
+        const now = Date.now();
+        const globalRateLimit = this.rateLimits.get('global');
+        if (globalRateLimit && now < globalRateLimit.resetAt) {
+            const waitTime = globalRateLimit.resetAt - now;
+            console.log(`Global rate limit active. Waiting ${waitTime}ms`);
+            await this.delay(waitTime);
+        }
+        const timeSinceLastRequest = now - this.lastRequestTime;
+        if (timeSinceLastRequest < this.minRequestInterval) {
+            const waitTime = this.minRequestInterval - timeSinceLastRequest;
+            await this.delay(waitTime);
+        }
+    }
+    updateRateLimitInfo(error) {
+        const retryAfter = error.retryAfter;
+        if (retryAfter) {
+            this.rateLimits.set('global', {
+                remaining: 0,
+                resetAt: Date.now() + retryAfter * 1000,
+            });
+        }
+    }
+    setNextDailyReset() {
+        const now = new Date();
+        this.dailyReset = new Date(now);
+        this.dailyReset.setUTCDate(this.dailyReset.getUTCDate() + 1);
+        this.dailyReset.setUTCHours(0, 0, 0, 0);
+    }
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+GlobalRequestQueue.instance = null;
+function getGlobalQueue() {
+    return GlobalRequestQueue.getInstance();
+}
+function withQueue(request, options) {
+    const queue = GlobalRequestQueue.getInstance();
+    return queue.enqueue(request, options);
+}
+
+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 });
+}
+
+class SecureTokenStorage {
+    constructor(config = {}) {
+        this.encryptionKey = null;
+        if (typeof window === 'undefined') {
+            throw new Error('SecureTokenStorage is only available in browser environments. ' +
+                'For Node.js, use EncryptedFileTokenStorage instead.');
+        }
+        if (!window.crypto || !window.crypto.subtle) {
+            throw new Error('Web Crypto API is not supported in this browser. ' +
+                'Please use a modern browser (Chrome 37+, Firefox 34+, Safari 11+, Edge 79+).');
+        }
+        this.keyPrefix = config.keyPrefix || 'etsy_token';
+        this.derivationInput = config.derivationInput || this.getDefaultDerivationInput();
+        this.storage = config.useSessionStorage ? sessionStorage : localStorage;
+    }
+    async save(tokens) {
+        const key = await this.getEncryptionKey();
+        const tokenJson = JSON.stringify(tokens);
+        const tokenData = new TextEncoder().encode(tokenJson);
+        const iv = window.crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await window.crypto.subtle.encrypt({
+            name: 'AES-GCM',
+            iv,
+        }, key, tokenData);
+        const integrity = await this.generateIntegrity(encrypted, iv);
+        const stored = {
+            version: 1,
+            encrypted: this.arrayBufferToBase64(encrypted),
+            iv: this.arrayBufferToBase64(iv),
+            integrity: this.arrayBufferToBase64(integrity),
+            expiresAt: tokens.expires_at.getTime(),
+            timestamp: Date.now(),
+        };
+        this.storage.setItem(this.keyPrefix, JSON.stringify(stored));
+    }
+    async load() {
+        const stored = this.storage.getItem(this.keyPrefix);
+        if (!stored) {
+            return null;
+        }
+        try {
+            const data = JSON.parse(stored);
+            if (data.version !== 1) {
+                console.warn('Unsupported token storage version. Clearing storage.');
+                await this.clear();
+                return null;
+            }
+            if (Date.now() > data.expiresAt) {
+                console.info('Stored tokens have expired. Clearing storage.');
+                await this.clear();
+                return null;
+            }
+            const encrypted = this.base64ToArrayBuffer(data.encrypted);
+            const iv = this.base64ToArrayBuffer(data.iv);
+            const storedIntegrity = this.base64ToArrayBuffer(data.integrity);
+            const computedIntegrity = await this.generateIntegrity(encrypted, iv);
+            if (!this.compareArrayBuffers(storedIntegrity, computedIntegrity)) {
+                console.warn('Token integrity check failed. Data may have been tampered with. Clearing storage.');
+                await this.clear();
+                return null;
+            }
+            const key = await this.getEncryptionKey();
+            const decrypted = await window.crypto.subtle.decrypt({
+                name: 'AES-GCM',
+                iv,
+            }, key, encrypted);
+            const tokenJson = new TextDecoder().decode(decrypted);
+            const tokens = JSON.parse(tokenJson);
+            tokens.expires_at = new Date(tokens.expires_at);
+            return tokens;
+        }
+        catch (error) {
+            console.error('Failed to load tokens from storage:', error);
+            await this.clear();
+            return null;
+        }
+    }
+    async clear() {
+        this.storage.removeItem(this.keyPrefix);
+    }
+    async getEncryptionKey() {
+        if (this.encryptionKey) {
+            return this.encryptionKey;
+        }
+        const keyMaterial = await this.deriveKeyMaterial();
+        this.encryptionKey = await window.crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt: this.stringToArrayBuffer('etsy-v3-api-client-salt'),
+            iterations: 100000,
+            hash: 'SHA-256',
+        }, keyMaterial, {
+            name: 'AES-GCM',
+            length: 256,
+        }, false, ['encrypt', 'decrypt']);
+        return this.encryptionKey;
+    }
+    async deriveKeyMaterial() {
+        const keyData = this.stringToArrayBuffer(this.derivationInput);
+        return window.crypto.subtle.importKey('raw', keyData, 'PBKDF2', false, ['deriveKey']);
+    }
+    async generateIntegrity(encrypted, iv) {
+        const combined = new Uint8Array(encrypted.byteLength + iv.byteLength);
+        combined.set(new Uint8Array(encrypted), 0);
+        combined.set(new Uint8Array(iv), encrypted.byteLength);
+        const keyMaterial = await this.deriveKeyMaterial();
+        const hmacKey = await window.crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt: this.stringToArrayBuffer('etsy-integrity-salt'),
+            iterations: 100000,
+            hash: 'SHA-256',
+        }, keyMaterial, {
+            name: 'HMAC',
+            hash: 'SHA-256',
+        }, false, ['sign']);
+        return window.crypto.subtle.sign('HMAC', hmacKey, combined);
+    }
+    getDefaultDerivationInput() {
+        const domain = window.location.hostname;
+        const userAgent = navigator.userAgent;
+        return `${domain}:${userAgent}`;
+    }
+    stringToArrayBuffer(str) {
+        return new TextEncoder().encode(str);
+    }
+    arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            const byte = bytes[i];
+            if (byte !== undefined) {
+                binary += String.fromCharCode(byte);
+            }
+        }
+        return btoa(binary);
+    }
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    compareArrayBuffers(a, b) {
+        if (a.byteLength !== b.byteLength) {
+            return false;
+        }
+        const viewA = new Uint8Array(a);
+        const viewB = new Uint8Array(b);
+        for (let i = 0; i < viewA.length; i++) {
+            if (viewA[i] !== viewB[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+function isSecureStorageSupported() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    return !!(window.crypto &&
+        window.crypto.subtle &&
+        typeof window.crypto.subtle.encrypt === 'function' &&
+        typeof window.crypto.subtle.decrypt === 'function' &&
+        typeof window.crypto.subtle.deriveKey === 'function');
+}
+
+class PluginManager {
+    constructor() {
+        this.plugins = [];
+    }
+    async register(plugin) {
+        if (this.plugins.some(p => p.name === plugin.name)) {
+            throw new Error(`Plugin with name "${plugin.name}" is already registered`);
+        }
+        this.plugins.push(plugin);
+        if (plugin.onInit) {
+            await plugin.onInit();
+        }
+    }
+    async unregister(pluginName) {
+        const index = this.plugins.findIndex(p => p.name === pluginName);
+        if (index === -1) {
+            return false;
+        }
+        const plugin = this.plugins[index];
+        if (!plugin) {
+            return false;
+        }
+        if (plugin.onDestroy) {
+            await plugin.onDestroy();
+        }
+        this.plugins.splice(index, 1);
+        return true;
+    }
+    getPlugins() {
+        return this.plugins;
+    }
+    getPlugin(name) {
+        return this.plugins.find(p => p.name === name);
+    }
+    async executeBeforeRequest(config) {
+        let currentConfig = config;
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeRequest) {
+                currentConfig = await plugin.onBeforeRequest(currentConfig);
+            }
+        }
+        return currentConfig;
+    }
+    async executeAfterResponse(response) {
+        let currentResponse = response;
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterResponse) {
+                currentResponse = await plugin.onAfterResponse(currentResponse);
+            }
+        }
+        return currentResponse;
+    }
+    async executeOnError(error) {
+        for (const plugin of this.plugins) {
+            if (plugin.onError) {
+                await plugin.onError(error);
+            }
+        }
+    }
+    async clear() {
+        for (const plugin of this.plugins) {
+            if (plugin.onDestroy) {
+                await plugin.onDestroy();
+            }
+        }
+        this.plugins = [];
+    }
+}
+function createAnalyticsPlugin(config) {
+    const requestTimes = new Map();
+    return {
+        name: 'analytics',
+        version: '1.0.0',
+        onBeforeRequest(requestConfig) {
+            const requestId = `${requestConfig.method}:${requestConfig.endpoint}:${Date.now()}`;
+            requestTimes.set(requestId, Date.now());
+            return requestConfig;
+        },
+        onAfterResponse(response) {
+            if (config.trackEndpoint) {
+                const requestId = Array.from(requestTimes.keys()).pop();
+                if (requestId) {
+                    const startTime = requestTimes.get(requestId);
+                    if (startTime) {
+                        const duration = Date.now() - startTime;
+                        const parts = requestId.split(':');
+                        const method = parts[0];
+                        const endpoint = parts[1];
+                        if (endpoint && method) {
+                            config.trackEndpoint(endpoint, method, duration);
+                        }
+                        requestTimes.delete(requestId);
+                    }
+                }
+            }
+            return response;
+        },
+        onError(error) {
+            if (config.trackError) {
+                config.trackError(error);
+            }
+        },
+    };
+}
+function createRetryPlugin(config = {}) {
+    const { retryableStatusCodes = [408, 429, 500, 502, 503, 504], } = config;
+    return {
+        name: 'retry',
+        version: '1.0.0',
+        async onError(error) {
+            if (error instanceof EtsyApiError) {
+                const statusCode = error.statusCode;
+                if (statusCode && retryableStatusCodes.includes(statusCode)) {
+                    if (config.onRetry) {
+                        config.onRetry(1, error);
+                    }
+                }
+            }
+        },
+    };
+}
+function createLoggingPlugin(config = {}) {
+    const logger = config.logger || console;
+    const logLevel = config.logLevel || 'info';
+    const shouldLog = (level) => {
+        const levels = ['debug', 'info', 'warn', 'error'];
+        const currentLevelIndex = levels.indexOf(logLevel);
+        const messageLevelIndex = levels.indexOf(level);
+        return messageLevelIndex >= currentLevelIndex;
+    };
+    return {
+        name: 'logging',
+        version: '1.0.0',
+        onBeforeRequest(requestConfig) {
+            if (shouldLog('debug')) {
+                logger.debug('[Etsy API] Request:', {
+                    method: requestConfig.method,
+                    endpoint: requestConfig.endpoint,
+                    params: requestConfig.params,
+                });
+            }
+            return requestConfig;
+        },
+        onAfterResponse(response) {
+            if (shouldLog('debug')) {
+                logger.debug('[Etsy API] Response:', {
+                    status: response.status,
+                    data: response.data,
+                });
+            }
+            return response;
+        },
+        onError(error) {
+            if (shouldLog('error')) {
+                logger.error('[Etsy API] Error:', error);
+                if (error instanceof EtsyApiError) {
+                    logger.error('[Etsy API] Error Details:', {
+                        statusCode: error.statusCode,
+                        endpoint: error.endpoint,
+                        suggestions: error.suggestions,
+                    });
+                }
+            }
+        },
+    };
+}
+function createCachingPlugin(config = {}) {
+    const cache = new Map();
+    const ttl = (config.ttl || 300) * 1000;
+    const generateKey = (requestConfig) => {
+        if (config.keyGenerator) {
+            return config.keyGenerator(requestConfig);
+        }
+        return `${requestConfig.method}:${requestConfig.endpoint}:${JSON.stringify(requestConfig.params || {})}`;
+    };
+    return {
+        name: 'caching',
+        version: '1.0.0',
+        onBeforeRequest(requestConfig) {
+            if (requestConfig.method.toUpperCase() === 'GET') {
+                const key = generateKey(requestConfig);
+                const cached = cache.get(key);
+                if (cached && Date.now() < cached.expiresAt) ;
+            }
+            return requestConfig;
+        },
+        onAfterResponse(response) {
+            const key = `GET:${response.status}`;
+            cache.set(key, {
+                data: response.data,
+                expiresAt: Date.now() + ttl,
+            });
+            return response;
+        },
+        onDestroy() {
+            cache.clear();
+        },
+    };
+}
+function createRateLimitPlugin(config = {}) {
+    const maxRequestsPerSecond = config.maxRequestsPerSecond || 10;
+    const requests = [];
+    return {
+        name: 'rateLimit',
+        version: '1.0.0',
+        async onBeforeRequest(requestConfig) {
+            const now = Date.now();
+            const oneSecondAgo = now - 1000;
+            while (requests.length > 0 && requests[0] !== undefined && requests[0] < oneSecondAgo) {
+                requests.shift();
+            }
+            if (requests.length >= maxRequestsPerSecond) {
+                if (config.onRateLimitExceeded) {
+                    config.onRateLimitExceeded();
+                }
+                const oldestRequest = requests[0];
+                if (oldestRequest !== undefined) {
+                    const waitTime = oldestRequest + 1000 - now;
+                    if (waitTime > 0) {
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                    }
+                }
+            }
+            requests.push(now);
+            return requestConfig;
+        },
+    };
+}
+
 function createEtsyClient(config) {
     return new EtsyClient(config);
 }
@@ -933,7 +3535,7 @@ function createTokenManager(config, storage) {
 function createRateLimiter(config) {
     return new EtsyRateLimiter(config);
 }
-const VERSION = '1.0.2';
+const VERSION = '2.2.0';
 const LIBRARY_NAME = 'etsy-v3-api-client';
 function getLibraryInfo() {
     return {
@@ -946,5 +3548,5 @@ function getLibraryInfo() {
     };
 }
 
-export { AuthHelper, COMMON_SCOPE_COMBINATIONS, ETSY_SCOPES, EtsyApiError, EtsyAuthError, EtsyClient, EtsyRateLimitError, EtsyRateLimiter, FileTokenStorage, LIBRARY_NAME, LocalStorageTokenStorage, MemoryTokenStorage, SessionStorageTokenStorage, TokenManager, VERSION, createAuthHelper, createCodeChallenge, createDefaultTokenStorage, createEtsyClient, createRateLimiter, createTokenManager, EtsyClient as default, defaultRateLimiter, generateCodeVerifier, generateRandomBase64Url, generateState, getAvailableStorage, getEnvironmentInfo, getLibraryInfo, hasLocalStorage, hasSessionStorage, isBrowser$1 as isBrowser, isNode$1 as isNode, sha256, sha256Base64Url };
+export { AuthHelper, BatchQueryExecutor, BulkOperationManager, COMMON_SCOPE_COMBINATIONS, CacheWithInvalidation, CreateListingSchema, DEFAULT_RETRY_CONFIG, ETSY_SCOPES, EncryptedFileTokenStorage, EtsyApiError, EtsyAuthError, EtsyClient, EtsyRateLimitError, EtsyRateLimiter, EtsyWebhookHandler, FieldValidator, FileTokenStorage, GlobalRequestQueue, LFUCache, LIBRARY_NAME, LRUCache, ListingQueryBuilder, LocalStorageTokenStorage, MemoryTokenStorage, PaginatedResults, PluginManager, ReceiptQueryBuilder, RedisCacheStorage, RetryManager, SecureTokenStorage, SessionStorageTokenStorage, TokenManager, UpdateListingSchema, UpdateShopSchema, VERSION, ValidationException, Validator, WebhookSecurity, combineValidators, createAnalyticsPlugin, createAuthHelper, createBatchQuery, createBulkOperationManager, createCacheStorage, createCacheWithInvalidation, createCachingPlugin, createCodeChallenge, createDefaultTokenStorage, createEtsyClient, createListingQuery, createLoggingPlugin, createPaginatedResults, createRateLimitPlugin, createRateLimiter, createReceiptQuery, createRedisCacheStorage, createRetryPlugin, createTokenManager, createValidator, createWebhookHandler, createWebhookSecurity, decryptAES256GCM, EtsyClient as default, defaultRateLimiter, deriveKeyFromPassword, encryptAES256GCM, executeBulkOperation, field, generateCodeVerifier, generateEncryptionKey, generateRandomBase64Url, generateState, getAvailableStorage, getEnvironmentInfo, getGlobalQueue, getLibraryInfo, hasLocalStorage, hasSessionStorage, isBrowser$1 as isBrowser, isNode$1 as isNode, isSecureStorageSupported, sha256, sha256Base64Url, validate, validateEncryptionKey, validateOrThrow, withQueryBuilder, withQueue, withRetry };
 //# sourceMappingURL=node.esm.js.map