e621 2.2.6 → 3.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Donovan Daniels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,13 +2,23 @@
 
 The most comprehensive wrapper for e621 you'll ever find.
 
-We support almost anything normal users can do, with plans to bring everything else in, and more later in development.
-
-See the [Features List](Features/README.md) for all of the things this module supports, and what is planned.
+We have as close to 100% coverage of the API as possible.
 
 ### This module is not officially supported or endorsed by any of the e621 staff. Do not go to them if something does not work.
 
-<hr>
+Documentation on the available methods and their inputs can be found in the [docs](https://js.e621.wiki). The actual implementation of methods is generated from the [OpenAPI Spec](https://e621.wiki), so if a parameter is missing, a path is wrong, a route is missing, etc., then it should be reported to the spec's repository and not here.
+
+## Installation
+
+NodeJS **20.19.0** or higher is required.
+
+```bash
+npm install e621
+```
+
+**This package is ESM only. [Your project should be too.](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c)**
+
+## Usage
 
 This module is structured with submodules corresponding to separate areas of the site. All of these modules are on the primary class, which can be constructed like so:
 ```typescript
@@ -26,40 +36,3 @@ const e621 = new E621({
 // all of the available modules stem from this main class,
 // e.g. use e621.posts.METHOD(), e621.users.METHOD()
 ```
-
-#### Options
-Most of these options shouldn't be used unless you know what you're doing (you probably only need `authUser` and `authKey`, and you can set `userAgent`)
-| Option | Type | Default | Description |
-|:---:|:---:|:---:|:---:|
-| `authUser` | String | None | User for authentication |
-| `authKey` | String | None | Token for authentication |
-| `userAgent` | String | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L57-L59) | UserAgent for requests |
-
-#### Instance Options
-These are set via the `setInstance` function.
-| Option | Type | Default | Description |
-|:---:|:---:|:---:|:---:|
-| `reconstructStaticURL` | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/util/RequestHandler.ts#L254-L256) | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L19-L23) | Override default url reconstruction |
-| `imageReconstructionType` | "e621" \| "yiffy" \| "local" \| null | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L35) | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L37) |
-| `ssl` | Boolean | [^1] | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L5) |
-| `port` | Number | [^1] | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L11) |
-| `host` | String | [^1] | [See Code](https://github.com/DonovanDMC/E621/blob/4bc4e2db7cc8389635d710a852ab6a88a0570602/src/types/index.d.ts#L15) |
-
-[^1]: This is very dependent on where this function is used. If used on a subclass, like `Yiffy` or `Dev` the defaults will be set to something else, but otherwise they are: true, 443, e621.net
-
-### Using YiffyAPI or E621 Dev?
-We've got built in classes for both. E621 dev assumes you're using [e621ng@ce871e4](https://github.com/zwagoth/e621ng/commit/ce871e412c4d2e1e2478a0e5049d20c77cd3f4d7) or later, as they changed where the dev site is accessed in this commit.
-you can use the built in sub-classes `E621.YiffyAPI` `E621.Dev` to access these, and for anything else: there's `E621.Custom`
-```ts
-import E621 from "e621"; // or import { YiffyAPI, Dev, Custom } from "e621";
-
-// first and only parameter is Options
-const yapi = new E621.Yiffy();
-const dev = new E621.Dev();
-// first parameter is Options, second is InstanceOptions
-const custom = new E621.Custom({}, {
-	host: "example.com",
-	port: 443,
-	ssl: true
-});
-```

package/dist/lib/Debug.d.ts

@@ -0,0 +1 @@
+export default function Debug(namespace: string, formatter: any, ...args: Array<any>): void;

package/dist/lib/Debug.js

@@ -0,0 +1,16 @@
+let pDebug, debug;
+await import("persistent-debug").then(module => {
+    pDebug = module.default;
+}, () => { });
+await import("debug").then(module => {
+    debug = module.default;
+}, () => { });
+export default function Debug(namespace, formatter, ...args) {
+    if (pDebug) {
+        pDebug(`e621:${namespace}`, formatter, ...args);
+    }
+    else if (debug) {
+        debug(`e621:${namespace}`)(formatter, ...args);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVidWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvRGVidWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsSUFBSSxNQUEwQyxFQUFFLEtBQXFDLENBQUM7QUFDdEYsTUFBTSxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUU7SUFDM0MsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUM7QUFDNUIsQ0FBQyxFQUFFLEdBQUcsRUFBRSxHQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ2IsTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFO0lBQ2hDLEtBQUssR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDO0FBQzNCLENBQUMsRUFBRSxHQUFHLEVBQUUsR0FBRSxDQUFDLENBQUMsQ0FBQztBQUViLE1BQU0sQ0FBQyxPQUFPLFVBQVUsS0FBSyxDQUFDLFNBQWlCLEVBQUUsU0FBYyxFQUFFLEdBQUcsSUFBZ0I7SUFDaEYsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUNULE1BQU0sQ0FBQyxRQUFRLFNBQVMsRUFBRSxFQUFFLFNBQVMsRUFBRSxHQUFHLElBQUksQ0FBQyxDQUFDO0lBQ3BELENBQUM7U0FBTSxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQ2YsS0FBSyxDQUFDLFFBQVEsU0FBUyxFQUFFLENBQUMsQ0FBQyxTQUFTLEVBQUUsR0FBRyxJQUFJLENBQUMsQ0FBQztJQUVuRCxDQUFDO0FBQ0wsQ0FBQyJ9

package/dist/lib/errors.d.ts

@@ -0,0 +1,8 @@
+/** @category Errors */
+export declare class UnexpectedResponseError extends Error {
+    error: unknown;
+    name: string;
+    request: Request;
+    response: Response;
+    constructor(request: Request, response: Response, error: unknown);
+}

package/dist/lib/errors.js

@@ -0,0 +1,37 @@
+/** @category Errors */
+export class UnexpectedResponseError extends Error {
+    error;
+    name = "UnexpectedResponseError";
+    request;
+    response;
+    constructor(request, response, error) {
+        let message = `Unexpected ${response.status} ${response.statusText} on ${request.method} ${request.url}`;
+        if (error) {
+            if (typeof error === "string")
+                message += `\n${error}`;
+            else if (error instanceof Error)
+                message += `\n${error.message}`;
+            else if (typeof error === "object" && error !== null) {
+                if ("message" in error && typeof error.message === "string")
+                    message += `\n${error.message}`;
+                else if ("error" in error && typeof error.error === "string")
+                    message += `\n${error.error}`;
+                else if ("errors" in error && typeof error.errors === "object" && error.errors !== null) {
+                    for (const [key, value] of Object.entries(error.errors)) {
+                        if (typeof value === "string")
+                            message += `\n${key}: ${value}`;
+                        else if (Array.isArray(value))
+                            message += `\n${key}: ${value.join(", ")}`;
+                    }
+                }
+            }
+        }
+        super(message);
+        Object.defineProperties(this, {
+            request: { value: request, enumerable: false },
+            response: { value: response, enumerable: false },
+            error: { value: error, enumerable: false }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/generated/client/client.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Config } from './types.js';
+export declare const createClient: (config?: Config) => Client;

package/dist/lib/generated/client/client.js

@@ -0,0 +1,236 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from '../core/serverSentEvents.js';
+import { getValidRequestBody } from '../core/utils.js';
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.js';
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams({
+                ...opts,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const url = buildUrl(opts);
+        return { opts, url };
+    };
+    const request = async (options) => {
+        // @ts-expect-error
+        const { opts, url } = await beforeRequest(options);
+        const requestInit = {
+            redirect: 'follow',
+            ...opts,
+            body: getValidRequestBody(opts),
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request.fns) {
+            if (fn) {
+                request = await fn(request, opts);
+            }
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = opts.fetch;
+        let response;
+        try {
+            response = await _fetch(request);
+        }
+        catch (error) {
+            // Handle fetch exceptions (AbortError, network errors, etc.)
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = (await fn(error, undefined, request, opts));
+                }
+            }
+            finalError = finalError || {};
+            if (opts.throwOnError) {
+                throw finalError;
+            }
+            // Return error response
+            return opts.responseStyle === 'data'
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response: undefined,
+                };
+        }
+        for (const fn of interceptors.response.fns) {
+            if (fn) {
+                response = await fn(response, request, opts);
+            }
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            const parseAs = (opts.parseAs === 'auto'
+                ? getParseAs(response.headers.get('Content-Type'))
+                : opts.parseAs) ?? 'json';
+            if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                let emptyData;
+                switch (parseAs) {
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'text':
+                        emptyData = await response[parseAs]();
+                        break;
+                    case 'formData':
+                        emptyData = new FormData();
+                        break;
+                    case 'stream':
+                        emptyData = response.body;
+                        break;
+                    case 'json':
+                    default:
+                        emptyData = {};
+                        break;
+                }
+                return opts.responseStyle === 'data'
+                    ? emptyData
+                    : {
+                        data: emptyData,
+                        ...result,
+                    };
+            }
+            let data;
+            switch (parseAs) {
+                case 'arrayBuffer':
+                case 'blob':
+                case 'formData':
+                case 'text':
+                    data = await response[parseAs]();
+                    break;
+                case 'json': {
+                    // Some servers return 200 with no Content-Length and empty body.
+                    // response.json() would throw; read as text and parse if non-empty.
+                    const text = await response.text();
+                    data = text ? JSON.parse(text) : {};
+                    break;
+                }
+                case 'stream':
+                    return opts.responseStyle === 'data'
+                        ? response.body
+                        : {
+                            data: response.body,
+                            ...result,
+                        };
+            }
+            if (parseAs === 'json') {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+            return opts.responseStyle === 'data'
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch {
+            // noop
+        }
+        const error = jsonError ?? textError;
+        let finalError = error;
+        for (const fn of interceptors.error.fns) {
+            if (fn) {
+                finalError = (await fn(error, response, request, opts));
+            }
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        // TODO: we probably want to return error and improve types
+        return opts.responseStyle === 'data'
+            ? undefined
+            : {
+                error: finalError,
+                ...result,
+            };
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            headers: opts.headers,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+    return {
+        buildUrl: _buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE'),
+        },
+        trace: makeMethodFn('TRACE'),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../lib/generated/client/client.ts"],"names":[],"mappings":"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"}

package/dist/lib/generated/client/index.d.ts

@@ -0,0 +1,8 @@
+export type { Auth } from '../core/auth.js';
+export type { QuerySerializerOptions } from '../core/bodySerializer.js';
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.js';
+export { buildClientParams } from '../core/params.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.js';
+export { createClient } from './client.js';
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.js';
+export { createConfig, mergeHeaders } from './utils.js';

package/dist/lib/generated/client/index.js

@@ -0,0 +1,7 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.js';
+export { buildClientParams } from '../core/params.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.js';
+export { createClient } from './client.js';
+export { createConfig, mergeHeaders } from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvZ2VuZXJhdGVkL2NsaWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxREFBcUQ7QUFJckQsT0FBTyxFQUNMLHNCQUFzQixFQUN0QixrQkFBa0IsRUFDbEIsNkJBQTZCLEdBQzlCLE1BQU0sMkJBQTJCLENBQUM7QUFDbkMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDdEQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDdkUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGFBQWEsQ0FBQztBQWEzQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQyJ9

package/dist/lib/generated/client/types.d.ts

@@ -0,0 +1,117 @@
+import type { Auth } from '../core/auth.js';
+import type { ServerSentEventsOptions, ServerSentEventsResult } from '../core/serverSentEvents.js';
+import type { Client as CoreClient, Config as CoreConfig } from '../core/types.js';
+import type { Middleware } from './utils.js';
+export type ResponseStyle = 'data' | 'fields';
+export interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, CoreConfig {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+export interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+export interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options<TData>) => string;
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+export interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+export {};

package/dist/lib/generated/client/types.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvZ2VuZXJhdGVkL2NsaWVudC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxREFBcUQifQ==

package/dist/lib/generated/client/utils.d.ts

@@ -0,0 +1,33 @@
+import type { QuerySerializerOptions } from '../core/bodySerializer.js';
+import type { Client, ClientOptions, Config, RequestOptions } from './types.js';
+export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => (queryParams: T) => string;
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export declare const getParseAs: (contentType: string | null) => Exclude<Config["parseAs"], "auto">;
+export declare const setAuthParams: ({ security, ...options }: Pick<Required<RequestOptions>, "security"> & Pick<RequestOptions, "auth" | "query"> & {
+    headers: Headers;
+}) => Promise<void>;
+export declare const buildUrl: Client['buildUrl'];
+export declare const mergeConfigs: (a: Config, b: Config) => Config;
+export declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+export interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+export declare const createInterceptors: <Req, Res, Err, Options>() => Middleware<Req, Res, Err, Options>;
+export declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>;
+export {};