@hey-api/openapi-ts 0.53.1 → 0.53.3

package/dist/index.d.cts

@@ -0,0 +1,776 @@
+import { rmSync } from 'node:fs';
+import ts from 'typescript';
+
+interface Dictionary<T = unknown> {
+    [key: string]: T;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#reference-object
+ */
+interface OpenApiReference$1 {
+    $ref?: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#example-object
+ */
+interface OpenApiExample extends OpenApiReference$1 {
+    description?: string;
+    externalValue?: string;
+    summary?: string;
+    value?: unknown;
+}
+
+interface WithEnumExtension {
+    'x-enum-descriptions'?: ReadonlyArray<string>;
+    'x-enum-varnames'?: ReadonlyArray<string>;
+    'x-enumNames'?: ReadonlyArray<string>;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#discriminator-object
+ */
+interface OpenApiDiscriminator {
+    mapping?: Dictionary<string>;
+    propertyName: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#external-documentation-object
+ */
+interface OpenApiExternalDocs$1 {
+    description?: string;
+    url: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#xml-object
+ */
+interface OpenApiXml$1 {
+    attribute?: boolean;
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    wrapped?: boolean;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#schema-object
+ */
+interface OpenApiSchema$1 extends OpenApiReference$1, WithEnumExtension {
+    additionalProperties?: boolean | OpenApiSchema$1;
+    allOf?: OpenApiSchema$1[];
+    anyOf?: OpenApiSchema$1[];
+    const?: string | number | boolean | null;
+    default?: unknown;
+    deprecated?: boolean;
+    description?: string;
+    discriminator?: OpenApiDiscriminator;
+    enum?: (string | number)[];
+    example?: unknown;
+    exclusiveMaximum?: boolean;
+    exclusiveMinimum?: boolean;
+    externalDocs?: OpenApiExternalDocs$1;
+    format?: 'binary' | 'boolean' | 'byte' | 'date-time' | 'date' | 'double' | 'float' | 'int32' | 'int64' | 'password' | 'string';
+    items?: OpenApiSchema$1;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    maximum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    minimum?: number;
+    multipleOf?: number;
+    not?: OpenApiSchema$1[];
+    nullable?: boolean;
+    oneOf?: OpenApiSchema$1[];
+    pattern?: string;
+    prefixItems?: OpenApiSchema$1[];
+    properties?: Dictionary<OpenApiSchema$1>;
+    readOnly?: boolean;
+    required?: string[];
+    title?: string;
+    type?: string | string[];
+    uniqueItems?: boolean;
+    writeOnly?: boolean;
+    xml?: OpenApiXml$1;
+}
+
+/**
+ * add only one type for now as that's needed to resolve the reported issue,
+ * more types should be added though
+ * {@link https://github.com/hey-api/openapi-ts/issues/612}
+ */
+type MediaType = 'application/json';
+/**
+ * encoding interface should be added, not adding it for now as it's not needed
+ * to resolve the issue reported
+ * {@link https://github.com/hey-api/openapi-ts/issues/612}
+ */
+interface MediaTypeObject {
+    example?: unknown;
+    examples?: Dictionary<OpenApiExample>;
+    schema: OpenApiSchema$1;
+}
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object
+ */
+interface OpenApiParameter extends OpenApiReference$1 {
+    allowEmptyValue?: boolean;
+    allowReserved?: boolean;
+    content?: Record<MediaType, MediaTypeObject>;
+    deprecated?: boolean;
+    description?: string;
+    example?: unknown;
+    examples?: Dictionary<OpenApiExample>;
+    explode?: boolean;
+    in: 'cookie' | 'formData' | 'header' | 'path' | 'query';
+    name: string;
+    nullable?: boolean;
+    required?: boolean;
+    schema?: OpenApiSchema$1;
+    style?: string;
+}
+
+interface Enum {
+    customDescription?: string;
+    customName?: string;
+    description?: string;
+    value: string | number;
+}
+interface OperationParameter extends Model {
+    in: 'body' | 'cookie' | 'formData' | 'header' | 'path' | 'query';
+    mediaType: string | null;
+    prop: string;
+}
+interface OperationParameters extends Pick<Model, '$refs' | 'imports'> {
+    parameters: OperationParameter[];
+    parametersBody: OperationParameter | null;
+    parametersCookie: OperationParameter[];
+    parametersForm: OperationParameter[];
+    parametersHeader: OperationParameter[];
+    parametersPath: OperationParameter[];
+    parametersQuery: OperationParameter[];
+}
+interface OperationResponse extends Model {
+    code: number | 'default' | '1XX' | '2XX' | '3XX' | '4XX' | '5XX';
+    in: 'header' | 'response';
+    responseTypes: Array<'error' | 'success'>;
+}
+type Method = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+interface Operation$1 extends OperationParameters {
+    deprecated: boolean;
+    description: string | null;
+    /**
+     * The operationId from OpenAPI specification.
+     */
+    id: string | null;
+    method: Method;
+    name: string;
+    path: string;
+    responseHeader: string | null;
+    /**
+     * All operation responses defined in OpenAPI specification.
+     * Sorted by status code.
+     */
+    responses: OperationResponse[];
+    summary: string | null;
+    tags: string[] | null;
+}
+interface Schema {
+    default?: unknown;
+    exclusiveMaximum?: boolean;
+    exclusiveMinimum?: boolean;
+    format?: 'binary' | 'boolean' | 'byte' | 'date-time' | 'date' | 'double' | 'float' | 'int32' | 'int64' | 'password' | 'string';
+    isDefinition: boolean;
+    isNullable: boolean;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    maximum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    minimum?: number;
+    multipleOf?: number;
+    pattern?: string;
+    uniqueItems?: boolean;
+}
+interface ModelMeta {
+    /**
+     * Ref to the type in OpenAPI specification.
+     */
+    $ref: string;
+    /**
+     * Name passed to the initial `getModel()` call.
+     */
+    name: string;
+}
+interface Model extends Schema {
+    /**
+     * **Experimental.** Contains list of original refs so they can be used
+     * to access the schema from anywhere instead of relying on string name.
+     * This allows us to do things like detect type of ref.
+     */
+    $refs: string[];
+    base: string;
+    deprecated?: boolean;
+    description: string | null;
+    enum: Enum[];
+    enums: Model[];
+    export: 'all-of' | 'any-of' | 'array' | 'const' | 'dictionary' | 'enum' | 'generic' | 'interface' | 'one-of' | 'reference';
+    imports: string[];
+    in: OperationParameter['in'] | OpenApiParameter['in'] | OperationResponse['in'] | '';
+    link: Model | Model[] | null;
+    meta?: ModelMeta;
+    /**
+     * @deprecated use `meta.name` instead
+     */
+    name: string;
+    properties: Model[];
+    template: string | null;
+    type: string;
+}
+interface Client$2 {
+    models: Model[];
+    operations: Operation$1[];
+    server: string;
+    /**
+     * Map of generated types where type names are keys. This is used to track
+     * uniquely generated types as we may want to deduplicate if there are
+     * multiple definitions with the same name but different value, or if we
+     * want to transform names.
+     */
+    types: Record<string, ModelMeta>;
+    version: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#external-documentation-object
+ */
+interface OpenApiExternalDocs {
+    description?: string;
+    url: string;
+}
+
+interface WithNullableExtension {
+    'x-nullable'?: boolean;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#reference-object
+ */
+interface OpenApiReference {
+    $ref?: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#xml-object
+ */
+interface OpenApiXml {
+    attribute?: boolean;
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    wrapped?: boolean;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#schema-object
+ */
+interface OpenApiSchema extends OpenApiReference, WithEnumExtension, WithNullableExtension {
+    additionalProperties?: boolean | OpenApiSchema;
+    allOf?: OpenApiSchema[];
+    default?: unknown;
+    description?: string;
+    discriminator?: string;
+    enum?: (string | number)[];
+    example?: unknown;
+    exclusiveMaximum?: boolean;
+    exclusiveMinimum?: boolean;
+    externalDocs?: OpenApiExternalDocs;
+    format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
+    items?: OpenApiSchema;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    maximum?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
+    minimum?: number;
+    multipleOf?: number;
+    pattern?: string;
+    properties?: Dictionary<OpenApiSchema>;
+    readOnly?: boolean;
+    required?: string[];
+    title?: string;
+    type?: string;
+    uniqueItems?: boolean;
+    xml?: OpenApiXml;
+}
+
+interface Operation extends Omit<Operation$1, 'tags'> {
+    service: string;
+}
+interface Service extends Pick<Model, '$refs' | 'imports' | 'name'> {
+    operations: Operation[];
+}
+interface Client$1 extends Omit<Client$2, 'operations'> {
+    services: Service[];
+}
+
+interface ImportExportItemObject {
+    alias?: string;
+    asType?: boolean;
+    name: string;
+}
+
+declare class TypeScriptFile {
+    private _headers;
+    private _imports;
+    private _items;
+    private _name;
+    private _path;
+    constructor({ dir, name, header, }: {
+        dir: string;
+        header?: boolean;
+        name: string;
+    });
+    add(...nodes: Array<ts.Node | string>): void;
+    /**
+     * Adds an import to the provided module. Handles duplication, returns added import.
+     */
+    import({ module, ...importedItem }: ImportExportItemObject & {
+        module: string;
+    }): ImportExportItemObject;
+    getName(withExtension?: boolean): string;
+    isEmpty(): boolean;
+    remove(options?: Parameters<typeof rmSync>[1]): void;
+    /**
+     * Removes last node form the stack. Works as undo.
+     */
+    removeNode(): void;
+    private _setName;
+    toString(separator?: string): string;
+    write(separator?: string): void;
+}
+
+type ExtractFromArray<T, Discriminator> = T extends Discriminator ? Required<T> : never;
+/**
+ * Accepts an array of elements union and attempts to extract only objects.
+ * For example, Array<string | number | { id: string }> would result in
+ * Array<{ id: string }>.
+ */
+type ExtractArrayOfObjects<T, Discriminator> = T extends Array<infer U> ? Array<ExtractFromArray<U, Discriminator>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<ExtractFromArray<U, Discriminator>> : never;
+type Files = Record<string, TypeScriptFile>;
+
+interface PluginDefinition {
+    handler: (args: {
+        client: Client$1;
+        files: Files;
+        outputParts: string[];
+        plugin: Config['plugins'][number];
+    }) => void;
+    name: string;
+    output?: string;
+}
+
+interface PluginConfig$6 extends PluginDefinition {
+    /**
+     * Generate Hey API schemas from the provided input.
+     */
+    name: '@hey-api/schemas';
+    /**
+     * Name of the generated file.
+     * @default 'schemas'
+     */
+    output?: string;
+}
+
+interface PluginConfig$5 extends PluginDefinition {
+    /**
+     * Generate Hey API services from the provided input.
+     */
+    name: '@hey-api/services';
+    /**
+     * Name of the generated file.
+     * @default 'services'
+     */
+    output?: string;
+}
+
+interface PluginConfig$4 extends PluginDefinition {
+    /**
+     * Generate Hey API types from the provided input.
+     */
+    name: '@hey-api/types';
+    /**
+     * Name of the generated file.
+     * @default 'types'
+     */
+    output?: string;
+}
+
+interface PluginConfig$3 extends PluginDefinition {
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
+     * @default true
+     */
+    infiniteQueryOptions?: boolean;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/useMutation `useMutation()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests.
+     * @default true
+     */
+    mutationOptions?: boolean;
+    /**
+     * Generate TanStack React Query output from the provided input.
+     */
+    name: '@tanstack/react-query';
+    /**
+     * Name of the generated file.
+     * @default '@tanstack/react-query'
+     */
+    output?: string;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions `queryOptions()`} helpers?
+     * These will be generated from all requests.
+     * @default true
+     */
+    queryOptions?: boolean;
+}
+
+interface PluginConfig$2 extends PluginDefinition {
+    /**
+     * Generate `createInfiniteQuery()` helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
+     * @default true
+     */
+    infiniteQueryOptions?: boolean;
+    /**
+     * Generate `createMutation()` helpers? These will be generated from DELETE, PATCH, POST, and PUT requests.
+     * @default true
+     */
+    mutationOptions?: boolean;
+    /**
+     * Generate TanStack Solid Query output from the provided input.
+     */
+    name: '@tanstack/solid-query';
+    /**
+     * Name of the generated file.
+     * @default '@tanstack/solid-query'
+     */
+    output?: string;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery `createQuery()`} helpers?
+     * These will be generated from all requests.
+     * @default true
+     */
+    queryOptions?: boolean;
+}
+
+interface PluginConfig$1 extends PluginDefinition {
+    /**
+     * Generate `createInfiniteQuery()` helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
+     * @default true
+     */
+    infiniteQueryOptions?: boolean;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation `createMutation()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests.
+     * @default true
+     */
+    mutationOptions?: boolean;
+    /**
+     * Generate TanStack Svelte Query output from the provided input.
+     */
+    name: '@tanstack/svelte-query';
+    /**
+     * Name of the generated file.
+     * @default '@tanstack/svelte-query'
+     */
+    output?: string;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery `createQuery()`} helpers?
+     * These will be generated from all requests.
+     * @default true
+     */
+    queryOptions?: boolean;
+}
+
+interface PluginConfig extends PluginDefinition {
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
+     * @default true
+     */
+    infiniteQueryOptions?: boolean;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation `useMutation()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests.
+     * @default true
+     */
+    mutationOptions?: boolean;
+    /**
+     * Generate TanStack Vue Query output from the provided input.
+     */
+    name: '@tanstack/vue-query';
+    /**
+     * Name of the generated file.
+     * @default '@tanstack/vue-query'
+     */
+    output?: string;
+    /**
+     * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/guides/query-options `queryOptions()`} helpers?
+     * These will be generated from all requests.
+     * @default true
+     */
+    queryOptions?: boolean;
+}
+
+type Plugins = PluginConfig$6 | PluginConfig$5 | PluginConfig$4 | PluginConfig$3 | PluginConfig$2 | PluginConfig$1 | PluginConfig;
+
+declare const CLIENTS: readonly ["@hey-api/client-axios", "@hey-api/client-fetch", "legacy/angular", "legacy/axios", "legacy/fetch", "legacy/node", "legacy/xhr"];
+type Client = (typeof CLIENTS)[number];
+interface ClientConfig {
+    /**
+     * Manually set base in OpenAPI config instead of inferring from server value
+     * @deprecated
+     */
+    base?: string;
+    /**
+     * HTTP client to generate
+     */
+    client?: Client | false | {
+        /**
+         * Bundle the client module? Set this to true if you're using a standalone
+         * client package and don't want to declare it as a separate dependency.
+         * When true, the client module will be generated from the standalone
+         * package and bundled with the rest of the generated output. This is
+         * useful if you're repackaging the output, publishing it to other users,
+         * and you don't want them to install any dependencies.
+         * @default false
+         */
+        bundle?: boolean;
+        /**
+         * HTTP client to generate
+         */
+        name: Client;
+    };
+    /**
+     * Path to the config file. Set this value if you don't use the default
+     * config file name, or it's not located in the project root.
+     */
+    configFile?: string;
+    /**
+     * Run in debug mode?
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Skip writing files to disk?
+     * @default false
+     */
+    dryRun?: boolean;
+    /**
+     * Use the experimental parser?
+     * @default false
+     */
+    experimental_parser?: boolean;
+    /**
+     * Generate core client classes?
+     * @default true
+     */
+    exportCore?: boolean;
+    /**
+     * The relative location of the OpenAPI spec
+     */
+    input: string | Record<string, unknown>;
+    /**
+     * Custom client class name
+     * @deprecated
+     */
+    name?: string;
+    /**
+     * The relative location of the output directory
+     */
+    output: string | {
+        /**
+         * Process output folder with formatter?
+         * @default false
+         */
+        format?: 'biome' | 'prettier' | false;
+        /**
+         * Process output folder with linter?
+         * @default false
+         */
+        lint?: 'biome' | 'eslint' | false;
+        /**
+         * The relative location of the output directory
+         */
+        path: string;
+    };
+    /**
+     * Plugins are used to generate additional output files from provided input.
+     */
+    plugins?: ReadonlyArray<Plugins['name'] | Plugins>;
+    /**
+     * Path to custom request file
+     * @deprecated
+     */
+    request?: string;
+    /**
+     * Generate JSON schemas?
+     * @default true
+     */
+    schemas?: boolean | {
+        /**
+         * Generate JSON schemas?
+         * @default true
+         */
+        export?: boolean;
+        /**
+         * Customise the schema name. By default, `{{name}}Schema` is used. `name` is a
+         * valid JavaScript/TypeScript identifier, e.g. if your schema name is
+         * "Foo-Bar", `name` value would be "FooBar".
+         */
+        name?: (name: string, schema: OpenApiSchema | OpenApiSchema$1) => string;
+        /**
+         * Choose schema type to generate. Select 'form' if you don't want
+         * descriptions to reduce bundle size and you plan to use schemas
+         * for form validation
+         * @default 'json'
+         */
+        type?: 'form' | 'json';
+    };
+    /**
+     * Generate services?
+     * @default true
+     */
+    services?: boolean | string | {
+        /**
+         * Group operation methods into service classes? When enabled, you can
+         * select which classes to export with `services.include` and/or
+         * transform their names with `services.name`.
+         *
+         * Note that by enabling this option, your services will **NOT**
+         * support {@link https://developer.mozilla.org/docs/Glossary/Tree_shaking tree-shaking}.
+         * For this reason, it is disabled by default.
+         * @default false
+         */
+        asClass?: boolean;
+        /**
+         * Generate services?
+         * @default true
+         */
+        export?: boolean;
+        /**
+         * Filter endpoints to be included in the generated services.
+         * The provided string should be a regular expression where matched
+         * results will be included in the output. The input pattern this
+         * string will be tested against is `{method} {path}`. For example,
+         * you can match `POST /api/v1/foo` with `^POST /api/v1/foo$`.
+         */
+        filter?: string;
+        /**
+         * Include only service classes with names matching regular expression
+         *
+         * This option has no effect if `services.asClass` is `false`.
+         */
+        include?: string;
+        /**
+         * Customise the name of methods within the service. By default, {@link Operation.name} is used.
+         */
+        methodNameBuilder?: (operation: Operation) => string;
+        /**
+         * Customize the generated service class names. The name variable is
+         * obtained from your OpenAPI specification tags.
+         *
+         * This option has no effect if `services.asClass` is `false`.
+         * @default '{{name}}Service'
+         */
+        name?: string;
+        /**
+         * Use operation ID to generate operation names?
+         * @default true
+         */
+        operationId?: boolean;
+        /**
+         * Define shape of returned value from service calls
+         * @default 'body'
+         * @deprecated
+         */
+        response?: 'body' | 'response';
+    };
+    /**
+     * Generate types?
+     * @default true
+     */
+    types?: boolean | string | {
+        /**
+         * Output Date type and possibly runtime transform instead of string for format "date-time"
+         * @default false
+         */
+        dates?: boolean | 'types+transform' | 'types';
+        /**
+         * Generate enum definitions?
+         * @default false
+         */
+        enums?: 'javascript' | 'typescript' | 'typescript+namespace' | false;
+        /**
+         * Generate types?
+         * @default true
+         */
+        export?: boolean;
+        /**
+         * Include only types matching regular expression
+         */
+        include?: string;
+        /**
+         * Use your preferred naming pattern
+         * @default 'preserve'
+         */
+        name?: 'PascalCase' | 'preserve';
+        /**
+         * Generate a tree of types containing all operations? It will be named
+         * $OpenApiTs and is generated by default only when not using services.
+         */
+        tree?: boolean;
+    };
+    /**
+     * Use options or arguments functions
+     * @deprecated
+     * @default true
+     */
+    useOptions?: boolean;
+}
+interface UserConfig extends ClientConfig {
+}
+type Config = Omit<Required<ClientConfig>, 'base' | 'client' | 'name' | 'output' | 'plugins' | 'request' | 'schemas' | 'services' | 'types'> & Pick<ClientConfig, 'base' | 'name' | 'request'> & {
+    client: Extract<Required<ClientConfig>['client'], object>;
+    output: Extract<Required<ClientConfig>['output'], object>;
+    plugins: ExtractArrayOfObjects<Required<ClientConfig>['plugins'], {
+        name: string;
+    }>;
+    schemas: Extract<Required<ClientConfig>['schemas'], object>;
+    services: Extract<Required<ClientConfig>['services'], object>;
+    types: Extract<Required<ClientConfig>['types'], object>;
+};
+
+/**
+ * Generate the OpenAPI client. This method will read the OpenAPI specification and based on the
+ * given language it will generate the client, including the typed models, validation schemas,
+ * service layer, etc.
+ * @param userConfig {@link UserConfig} passed to the `createClient()` method
+ */
+declare function createClient(userConfig: UserConfig): Promise<ReadonlyArray<Client$1>>;
+/**
+ * Type helper for openapi-ts.config.ts, returns {@link UserConfig} object
+ */
+declare const defineConfig: (config: UserConfig) => UserConfig;
+declare const _default: {
+    createClient: typeof createClient;
+    defineConfig: (config: UserConfig) => UserConfig;
+};
+
+export { type UserConfig, createClient, _default as default, defineConfig };