recker 1.0.26 → 1.0.27

package/dist/browser/plugins/soap.js

@@ -0,0 +1,347 @@
+function jsToXmlRpcValue(value) {
+    if (value === null || value === undefined) {
+        return '<nil/>';
+    }
+    if (typeof value === 'boolean') {
+        return `<boolean>${value ? '1' : '0'}</boolean>`;
+    }
+    if (typeof value === 'number') {
+        if (Number.isInteger(value)) {
+            return `<int>${value}</int>`;
+        }
+        return `<double>${value}</double>`;
+    }
+    if (typeof value === 'string') {
+        return `<string>${escapeXml(value)}</string>`;
+    }
+    if (value instanceof Date) {
+        return `<dateTime.iso8601>${value.toISOString()}</dateTime.iso8601>`;
+    }
+    if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+        const base64 = Buffer.from(value).toString('base64');
+        return `<base64>${base64}</base64>`;
+    }
+    if (Array.isArray(value)) {
+        const items = value.map((item) => `<value>${jsToXmlRpcValue(item)}</value>`).join('');
+        return `<array><data>${items}</data></array>`;
+    }
+    if (typeof value === 'object') {
+        const members = Object.entries(value)
+            .map(([name, val]) => `<member><name>${escapeXml(name)}</name><value>${jsToXmlRpcValue(val)}</value></member>`)
+            .join('');
+        return `<struct>${members}</struct>`;
+    }
+    return `<string>${String(value)}</string>`;
+}
+function parseXmlRpcValue(xml) {
+    const trimmed = xml.trim();
+    if (trimmed.includes('<nil/>') || trimmed.includes('<nil></nil>')) {
+        return null;
+    }
+    if (trimmed.startsWith('<array>') || trimmed.includes('<array>')) {
+        const dataMatch = trimmed.match(/<array>\s*<data>([\s\S]*)<\/data>\s*<\/array>/);
+        if (dataMatch) {
+            const values = [];
+            const dataContent = dataMatch[1];
+            const valueParts = dataContent.split(/<\/value>/);
+            for (const part of valueParts) {
+                const valueStart = part.indexOf('<value>');
+                if (valueStart !== -1) {
+                    const content = part.slice(valueStart + 7);
+                    values.push(parseXmlRpcValue(content.trim()));
+                }
+            }
+            return values;
+        }
+    }
+    if (trimmed.startsWith('<struct>') || trimmed.includes('<struct>')) {
+        const structContent = trimmed.match(/<struct>([\s\S]*)<\/struct>/);
+        if (structContent) {
+            const obj = {};
+            const memberParts = structContent[1].split(/<\/member>/);
+            for (const part of memberParts) {
+                const memberStart = part.indexOf('<member>');
+                if (memberStart !== -1) {
+                    const memberContent = part.slice(memberStart + 8);
+                    const nameMatch = memberContent.match(/<name>([\s\S]*?)<\/name>/);
+                    const valueMatch = memberContent.match(/<value>([\s\S]*)<\/value>/s);
+                    if (nameMatch && valueMatch) {
+                        obj[unescapeXml(nameMatch[1].trim())] = parseXmlRpcValue(valueMatch[1].trim());
+                    }
+                }
+            }
+            return obj;
+        }
+    }
+    const intMatch = trimmed.match(/^<(?:int|i4|i8)>(-?\d+)<\/(?:int|i4|i8)>$/);
+    if (intMatch) {
+        return parseInt(intMatch[1], 10);
+    }
+    const boolMatch = trimmed.match(/^<boolean>([01])<\/boolean>$/);
+    if (boolMatch) {
+        return boolMatch[1] === '1';
+    }
+    const doubleMatch = trimmed.match(/^<double>(-?[\d.]+(?:[eE][+-]?\d+)?)<\/double>$/);
+    if (doubleMatch) {
+        return parseFloat(doubleMatch[1]);
+    }
+    const stringMatch = trimmed.match(/^<string>([\s\S]*?)<\/string>$/);
+    if (stringMatch) {
+        return unescapeXml(stringMatch[1]);
+    }
+    const dateMatch = trimmed.match(/^<dateTime\.iso8601>([\s\S]*?)<\/dateTime\.iso8601>$/);
+    if (dateMatch) {
+        return new Date(dateMatch[1]);
+    }
+    const base64Match = trimmed.match(/^<base64>([\s\S]*?)<\/base64>$/);
+    if (base64Match) {
+        return Buffer.from(base64Match[1], 'base64');
+    }
+    return trimmed;
+}
+export class XmlRpcClient {
+    client;
+    endpoint;
+    requestOptions;
+    constructor(client, options) {
+        this.client = client;
+        this.endpoint = options.endpoint;
+        this.requestOptions = options.requestOptions ?? {};
+    }
+    async call(method, params = []) {
+        const paramsXml = params.map((p) => `<param><value>${jsToXmlRpcValue(p)}</value></param>`).join('');
+        const xml = `<?xml version="1.0"?>
+<methodCall>
+  <methodName>${escapeXml(method)}</methodName>
+  <params>${paramsXml}</params>
+</methodCall>`;
+        const response = await this.client.post(this.endpoint, xml, {
+            ...this.requestOptions,
+            headers: {
+                'Content-Type': 'text/xml',
+                ...this.requestOptions.headers,
+            },
+        });
+        const responseXml = await response.text();
+        return this.parseResponse(responseXml);
+    }
+    parseResponse(xml) {
+        const faultMatch = xml.match(/<fault>\s*<value>([\s\S]+)<\/value>\s*<\/fault>/);
+        if (faultMatch) {
+            const fault = parseXmlRpcValue(faultMatch[1]);
+            return {
+                success: false,
+                fault: {
+                    faultCode: fault.faultCode ?? 0,
+                    faultString: fault.faultString ?? 'Unknown error',
+                },
+            };
+        }
+        const paramsMatch = xml.match(/<params>\s*<param>\s*<value>([\s\S]+)<\/value>\s*<\/param>\s*<\/params>/);
+        if (paramsMatch) {
+            return {
+                success: true,
+                result: parseXmlRpcValue(paramsMatch[1]),
+            };
+        }
+        return { success: true };
+    }
+}
+const SOAP_NAMESPACES = {
+    '1.1': {
+        envelope: 'http://schemas.xmlsoap.org/soap/envelope/',
+        contentType: 'text/xml; charset=utf-8',
+    },
+    '1.2': {
+        envelope: 'http://www.w3.org/2003/05/soap-envelope',
+        contentType: 'application/soap+xml; charset=utf-8',
+    },
+};
+export class SoapClient {
+    client;
+    options;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            endpoint: options.endpoint,
+            version: options.version ?? '1.2',
+            namespace: options.namespace ?? '',
+            namespacePrefix: options.namespacePrefix ?? 'ns',
+            wsdl: options.wsdl,
+            soapHeaders: options.soapHeaders ?? {},
+            requestOptions: options.requestOptions ?? {},
+        };
+    }
+    async call(method, params = {}, options) {
+        const soapNs = SOAP_NAMESPACES[this.options.version];
+        const prefix = this.options.namespacePrefix;
+        const ns = this.options.namespace;
+        const soapHeaders = { ...this.options.soapHeaders, ...options?.soapHeaders };
+        let soapHeaderXml = '';
+        if (Object.keys(soapHeaders).length > 0) {
+            const headerContent = this.objectToXml(soapHeaders, prefix);
+            soapHeaderXml = `<soap:Header>${headerContent}</soap:Header>`;
+        }
+        const paramsXml = this.objectToXml(params, prefix);
+        const methodXml = ns
+            ? `<${prefix}:${method} xmlns:${prefix}="${ns}">${paramsXml}</${prefix}:${method}>`
+            : `<${method}>${paramsXml}</${method}>`;
+        const envelope = `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:soap="${soapNs.envelope}">
+  ${soapHeaderXml}
+  <soap:Body>
+    ${methodXml}
+  </soap:Body>
+</soap:Envelope>`;
+        const headers = {
+            'Content-Type': soapNs.contentType,
+        };
+        if (this.options.version === '1.1') {
+            const action = options?.soapAction ?? `${ns}/${method}`;
+            headers['SOAPAction'] = `"${action}"`;
+        }
+        const response = await this.client.post(this.options.endpoint, envelope, {
+            ...this.options.requestOptions,
+            headers: {
+                ...headers,
+                ...this.options.requestOptions.headers,
+            },
+        });
+        const responseXml = await response.text();
+        return this.parseResponse(responseXml, method);
+    }
+    async getWsdl() {
+        if (!this.options.wsdl)
+            return null;
+        const response = await this.client.get(this.options.wsdl);
+        return response.text();
+    }
+    objectToXml(obj, prefix) {
+        return Object.entries(obj)
+            .map(([key, value]) => {
+            const tagName = prefix ? `${prefix}:${key}` : key;
+            if (value === null || value === undefined) {
+                return `<${tagName} xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>`;
+            }
+            if (typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                return `<${tagName}>${this.objectToXml(value)}</${tagName}>`;
+            }
+            if (Array.isArray(value)) {
+                return value.map((item) => {
+                    if (typeof item === 'object') {
+                        return `<${tagName}>${this.objectToXml(item)}</${tagName}>`;
+                    }
+                    return `<${tagName}>${escapeXml(String(item))}</${tagName}>`;
+                }).join('');
+            }
+            if (value instanceof Date) {
+                return `<${tagName}>${value.toISOString()}</${tagName}>`;
+            }
+            return `<${tagName}>${escapeXml(String(value))}</${tagName}>`;
+        })
+            .join('');
+    }
+    parseResponse(xml, method) {
+        const faultMatch = xml.match(/<(?:soap:|SOAP-ENV:|)[Ff]ault[^>]*>([\s\S]*?)<\/(?:soap:|SOAP-ENV:|)[Ff]ault>/i);
+        if (faultMatch) {
+            const faultXml = faultMatch[1];
+            const codeMatch = faultXml.match(/<faultcode[^>]*>([\s\S]*?)<\/faultcode>/i);
+            const stringMatch = faultXml.match(/<faultstring[^>]*>([\s\S]*?)<\/faultstring>/i);
+            const actorMatch = faultXml.match(/<faultactor[^>]*>([\s\S]*?)<\/faultactor>/i);
+            const detailMatch = faultXml.match(/<detail[^>]*>([\s\S]*?)<\/detail>/i);
+            const codeMatch12 = faultXml.match(/<(?:\w+:)?Code[^>]*>[\s\S]*?<(?:\w+:)?Value[^>]*>([\s\S]*?)<\/(?:\w+:)?Value>/i);
+            const reasonMatch12 = faultXml.match(/<(?:\w+:)?Reason[^>]*>[\s\S]*?<(?:\w+:)?Text[^>]*>([\s\S]*?)<\/(?:\w+:)?Text>/i);
+            return {
+                success: false,
+                fault: {
+                    code: unescapeXml(codeMatch?.[1] ?? codeMatch12?.[1] ?? 'Unknown'),
+                    string: unescapeXml(stringMatch?.[1] ?? reasonMatch12?.[1] ?? 'Unknown error'),
+                    actor: actorMatch ? unescapeXml(actorMatch[1]) : undefined,
+                    detail: detailMatch ? detailMatch[1] : undefined,
+                },
+                rawXml: xml,
+            };
+        }
+        const bodyMatch = xml.match(/<(?:soap:|SOAP-ENV:|)[Bb]ody[^>]*>([\s\S]*?)<\/(?:soap:|SOAP-ENV:|)[Bb]ody>/i);
+        if (!bodyMatch) {
+            return {
+                success: false,
+                fault: { code: 'ParseError', string: 'Could not parse SOAP response body' },
+                rawXml: xml,
+            };
+        }
+        const bodyContent = bodyMatch[1].trim();
+        const responseRegex = new RegExp(`<(?:\\w+:)?${method}(?:Response|Result)[^>]*>([\\s\\S]*?)<\\/(?:\\w+:)?${method}(?:Response|Result)>`, 'i');
+        const responseMatch = bodyContent.match(responseRegex);
+        const resultXml = responseMatch ? responseMatch[1] : bodyContent;
+        const result = this.parseXmlToObject(resultXml);
+        return {
+            success: true,
+            result: result,
+            rawXml: xml,
+        };
+    }
+    parseXmlToObject(xml) {
+        const trimmed = xml.trim();
+        if (!trimmed.startsWith('<')) {
+            return unescapeXml(trimmed);
+        }
+        const obj = {};
+        const elementRegex = /<([^\/][^>\s]*)[^>]*>([\s\S]*?)<\/\1>/g;
+        let match;
+        let hasElements = false;
+        while ((match = elementRegex.exec(trimmed)) !== null) {
+            hasElements = true;
+            const [, tagName, content] = match;
+            const key = tagName.includes(':') ? tagName.split(':')[1] : tagName;
+            const value = this.parseXmlToObject(content);
+            if (key in obj) {
+                if (Array.isArray(obj[key])) {
+                    obj[key].push(value);
+                }
+                else {
+                    obj[key] = [obj[key], value];
+                }
+            }
+            else {
+                obj[key] = value;
+            }
+        }
+        if (!hasElements) {
+            return unescapeXml(trimmed);
+        }
+        return obj;
+    }
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function unescapeXml(str) {
+    return str
+        .replace(/&apos;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&gt;/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&amp;/g, '&');
+}
+export function createXmlRpcClient(client, options) {
+    return new XmlRpcClient(client, options);
+}
+export function createSoapClient(client, options) {
+    return new SoapClient(client, options);
+}
+export function soap() {
+    return (client) => {
+        client.soap = (options) => {
+            return createSoapClient(client, options);
+        };
+        client.xmlrpc = (endpoint, requestOptions) => {
+            return createXmlRpcClient(client, { endpoint, requestOptions });
+        };
+    };
+}

package/dist/browser/plugins/xml.d.ts

@@ -0,0 +1,9 @@
+import { ReckerResponse } from '../types/index.js';
+export interface XMLPluginOptions {
+    parser?: (xml: string) => any;
+    serializer?: (obj: any) => string;
+}
+export declare function parseXML(xml: string): any;
+export declare function serializeXML(obj: any, rootName?: string): string;
+export declare function xmlResponse<T = any>(promise: Promise<ReckerResponse>, parser?: (xml: string) => any): Promise<T>;
+export { parseXML as parse, serializeXML as serialize };

package/dist/browser/plugins/xml.js

@@ -0,0 +1,194 @@
+export function parseXML(xml) {
+    const cleanXml = xml
+        .replace(/<\?xml[^?]*\?>/gi, '')
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .trim();
+    return parseElement(cleanXml);
+}
+function parseElement(xml) {
+    const rootMatch = xml.match(/^<(\w+)([^>]*)>([\s\S]*)<\/\1>$/);
+    if (!rootMatch) {
+        const selfClosingMatch = xml.match(/^<(\w+)([^/>]*)\/>$/);
+        if (selfClosingMatch) {
+            const [, tagName, attrs] = selfClosingMatch;
+            const attributes = parseAttributes(attrs);
+            return Object.keys(attributes).length > 0 ? { [tagName]: attributes } : { [tagName]: null };
+        }
+        return decodeXMLEntities(xml.trim());
+    }
+    const [, tagName, attrs, content] = rootMatch;
+    const attributes = parseAttributes(attrs);
+    const children = parseChildren(content);
+    const result = {};
+    if (Object.keys(attributes).length > 0) {
+        result['@attributes'] = attributes;
+    }
+    if (typeof children === 'string') {
+        if (Object.keys(attributes).length > 0) {
+            result['#text'] = children;
+            return { [tagName]: result };
+        }
+        return { [tagName]: children };
+    }
+    if (Array.isArray(children)) {
+        for (const child of children) {
+            for (const [key, value] of Object.entries(child)) {
+                if (result[key] !== undefined) {
+                    if (!Array.isArray(result[key])) {
+                        result[key] = [result[key]];
+                    }
+                    result[key].push(value);
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+        }
+    }
+    return { [tagName]: Object.keys(result).length > 0 ? result : null };
+}
+function parseAttributes(attrs) {
+    const result = {};
+    const attrRegex = /(\w+)=["']([^"']*)["']/g;
+    let match;
+    while ((match = attrRegex.exec(attrs)) !== null) {
+        result[match[1]] = decodeXMLEntities(match[2]);
+    }
+    return result;
+}
+function parseChildren(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return '';
+    if (!trimmed.startsWith('<')) {
+        return decodeXMLEntities(trimmed);
+    }
+    const children = [];
+    let remaining = trimmed;
+    while (remaining.length > 0) {
+        remaining = remaining.trim();
+        if (!remaining)
+            break;
+        const tagMatch = remaining.match(/^<(\w+)([^>]*)>/);
+        if (!tagMatch) {
+            const textEnd = remaining.indexOf('<');
+            if (textEnd > 0) {
+                const text = remaining.substring(0, textEnd).trim();
+                if (text) {
+                    children.push({ '#text': decodeXMLEntities(text) });
+                }
+                remaining = remaining.substring(textEnd);
+                continue;
+            }
+            break;
+        }
+        const [fullMatch, tagName, attrs] = tagMatch;
+        if (attrs.endsWith('/') || remaining.substring(fullMatch.length - 1, fullMatch.length + 1) === '/>') {
+            const selfMatch = remaining.match(/^<(\w+)([^/>]*)\/?>/);
+            if (selfMatch) {
+                const selfAttrs = parseAttributes(selfMatch[2]);
+                children.push({ [tagName]: Object.keys(selfAttrs).length > 0 ? { '@attributes': selfAttrs } : null });
+                remaining = remaining.substring(selfMatch[0].length);
+                continue;
+            }
+        }
+        const closingTag = `</${tagName}>`;
+        let depth = 1;
+        let pos = fullMatch.length;
+        while (depth > 0 && pos < remaining.length) {
+            const nextOpen = remaining.indexOf(`<${tagName}`, pos);
+            const nextClose = remaining.indexOf(closingTag, pos);
+            if (nextClose === -1)
+                break;
+            if (nextOpen !== -1 && nextOpen < nextClose) {
+                const afterOpen = remaining.substring(nextOpen);
+                const selfCloseMatch = afterOpen.match(/^<\w+[^>]*\/>/);
+                if (!selfCloseMatch) {
+                    depth++;
+                }
+                pos = nextOpen + 1;
+            }
+            else {
+                depth--;
+                if (depth === 0) {
+                    const elementXml = remaining.substring(0, nextClose + closingTag.length);
+                    children.push(parseElement(elementXml));
+                    remaining = remaining.substring(nextClose + closingTag.length);
+                }
+                else {
+                    pos = nextClose + 1;
+                }
+            }
+        }
+        if (depth > 0) {
+            break;
+        }
+    }
+    return children;
+}
+function decodeXMLEntities(str) {
+    return str
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10)))
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, code) => String.fromCharCode(parseInt(code, 16)));
+}
+export function serializeXML(obj, rootName) {
+    if (obj === null || obj === undefined) {
+        return rootName ? `<${rootName}/>` : '';
+    }
+    if (typeof obj !== 'object') {
+        return rootName ? `<${rootName}>${encodeXMLEntities(String(obj))}</${rootName}>` : encodeXMLEntities(String(obj));
+    }
+    const keys = Object.keys(obj);
+    if (keys.length === 1 && !rootName) {
+        const key = keys[0];
+        return serializeXML(obj[key], key);
+    }
+    let xml = '';
+    let attributes = '';
+    let textContent = '';
+    for (const key of keys) {
+        const value = obj[key];
+        if (key === '@attributes') {
+            for (const [attrName, attrValue] of Object.entries(value)) {
+                attributes += ` ${attrName}="${encodeXMLEntities(String(attrValue))}"`;
+            }
+        }
+        else if (key === '#text') {
+            textContent = encodeXMLEntities(String(value));
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                xml += serializeXML(item, key);
+            }
+        }
+        else {
+            xml += serializeXML(value, key);
+        }
+    }
+    if (rootName) {
+        if (xml || textContent) {
+            return `<${rootName}${attributes}>${textContent}${xml}</${rootName}>`;
+        }
+        return `<${rootName}${attributes}/>`;
+    }
+    return xml;
+}
+function encodeXMLEntities(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export async function xmlResponse(promise, parser = parseXML) {
+    const response = await promise;
+    const text = await response.text();
+    return parser(text);
+}
+export { parseXML as parse, serializeXML as serialize };

package/dist/browser/plugins/xsrf.d.ts

@@ -0,0 +1,9 @@
+import { Middleware } from '../types/index.js';
+export interface XSRFPluginOptions {
+    cookieName?: string;
+    headerName?: string;
+    token?: string;
+    cookies?: string;
+}
+export declare function xsrfPlugin(options?: XSRFPluginOptions): Middleware;
+export declare function createXSRFMiddleware(config: boolean | XSRFPluginOptions): Middleware | null;

package/dist/browser/plugins/xsrf.js

@@ -0,0 +1,48 @@
+function parseCookies(cookieString) {
+    const cookies = {};
+    if (!cookieString) {
+        return cookies;
+    }
+    const pairs = cookieString.split(';');
+    for (const pair of pairs) {
+        const [key, ...valueParts] = pair.split('=');
+        const trimmedKey = key?.trim();
+        const value = valueParts.join('=').trim();
+        if (trimmedKey) {
+            cookies[trimmedKey] = decodeURIComponent(value || '');
+        }
+    }
+    return cookies;
+}
+function getXSRFToken(cookieName, cookies) {
+    if (cookies) {
+        const parsed = parseCookies(cookies);
+        return parsed[cookieName] || null;
+    }
+    if (typeof document !== 'undefined' && document.cookie) {
+        const parsed = parseCookies(document.cookie);
+        return parsed[cookieName] || null;
+    }
+    return null;
+}
+export function xsrfPlugin(options = {}) {
+    const { cookieName = 'XSRF-TOKEN', headerName = 'X-XSRF-TOKEN', token: manualToken, cookies } = options;
+    return async (req, next) => {
+        const token = manualToken || getXSRFToken(cookieName, cookies);
+        if (token) {
+            if (!req.headers.has(headerName)) {
+                req.headers.set(headerName, token);
+            }
+        }
+        return next(req);
+    };
+}
+export function createXSRFMiddleware(config) {
+    if (!config) {
+        return null;
+    }
+    if (config === true) {
+        return xsrfPlugin();
+    }
+    return xsrfPlugin(config);
+}

package/dist/browser/recker.d.ts

@@ -0,0 +1,26 @@
+import { Client, type ExtendedClientOptions } from '../core/client.js';
+import { type RequestPromise } from '../core/request-promise.js';
+import type { RequestOptions } from '../types/index.js';
+export declare function get(url: string, options?: RequestOptions): RequestPromise;
+export declare function post(url: string, options?: RequestOptions): RequestPromise;
+export declare function put(url: string, options?: RequestOptions): RequestPromise;
+export declare function patch(url: string, options?: RequestOptions): RequestPromise;
+export declare function del(url: string, options?: RequestOptions): RequestPromise;
+export declare function head(url: string, options?: RequestOptions): RequestPromise;
+export declare function options(url: string, options?: RequestOptions): RequestPromise;
+export declare function ws(url: string, protocols?: string | string[]): WebSocket;
+export declare const recker: {
+    get: typeof get;
+    post: typeof post;
+    put: typeof put;
+    patch: typeof patch;
+    delete: typeof del;
+    head: typeof head;
+    options: typeof options;
+    ws: typeof ws;
+    client: (opts?: ExtendedClientOptions) => Client;
+    reset: () => void;
+    isBrowser: true;
+    unavailable: readonly ["whois", "whoisAvailable", "dns", "dnsSecurity", "dnsClient", "whoisClient", "ai", "aiClient"];
+};
+export default recker;