@goast/typescript 0.9.0 → 0.9.1

package/dist/src/generators/services/fetch-clients/fetch-client-generator.d.ts

@@ -6,10 +6,32 @@ import type { TypeScriptFetchClientGeneratorContext, TypeScriptFetchClientGenera
 type Context = TypeScriptFetchClientGeneratorContext;
 type Output = TypeScriptFetchClientGeneratorOutput;
 type Builder = TypeScriptFileBuilder;
+/**
+ * Generates the client class and/or the client interface of one API service.
+ * @template TOutput The type of the output returned for the service.
+ * @see DefaultTypeScriptFetchClientGenerator
+ */
 export interface TypeScriptFetchClientGenerator<TOutput extends Output = Output> {
+    /**
+     * Generates the files of the service in the context and returns the exports that were written.
+     * @param ctx The context of the service to generate.
+     * @returns The output for the service, or a promise that resolves to it.
+     */
     generate(ctx: Context): MaybePromise<TOutput>;
 }
+/**
+ * The default implementation of `TypeScriptFetchClientGenerator`. It writes the client interface to
+ * `{outputDir}/{clientInterfaceDir}/{service}.ts` and the client class to
+ * `{outputDir}/{clientDir}/{service}-client.ts`, as selected by `clientFileKind`, where `{service}` is the kebab-cased
+ * service name. Extend it to customize the output.
+ * @see TypeScriptFetchClientsGenerator
+ */
 export declare class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptFetchClientGenerator {
+    /**
+     * Generates the client interface and/or the client class of the service.
+     * @param ctx The context of the service to generate.
+     * @returns The `clientInterface` and `client` exports that were written, depending on `clientFileKind`.
+     */
     generate(ctx: Context): MaybePromise<Output>;
     protected getInterfaceFileContent(ctx: Context): AppendValueGroup<Builder>;
     protected getInterface(ctx: Context): ts.Interface<Builder>;

package/dist/src/generators/services/fetch-clients/fetch-client-generator.js

@@ -4,7 +4,19 @@ import { ts } from '../../../ast/index.js';
 import { TypeScriptFileBuilder } from '../../../file-builder.js';
 import { getSourceDocLine } from '../../../utils.js';
 import { TypeScriptFileGenerator } from '../../file-generator.js';
+/**
+ * The default implementation of `TypeScriptFetchClientGenerator`. It writes the client interface to
+ * `{outputDir}/{clientInterfaceDir}/{service}.ts` and the client class to
+ * `{outputDir}/{clientDir}/{service}-client.ts`, as selected by `clientFileKind`, where `{service}` is the kebab-cased
+ * service name. Extend it to customize the output.
+ * @see TypeScriptFetchClientsGenerator
+ */
 export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator {
+    /**
+     * Generates the client interface and/or the client class of the service.
+     * @param ctx The context of the service to generate.
+     * @returns The `clientInterface` and `client` exports that were written, depending on `clientFileKind`.
+     */
     generate(ctx) {
         const result = {};
         if (this.shouldGenerateInterface(ctx)) {

package/dist/src/generators/services/fetch-clients/fetch-clients-generator.d.ts

@@ -7,8 +7,25 @@ type Output = TypeScriptFetchClientsGeneratorOutput;
 type Config = TypeScriptFetchClientsGeneratorConfig;
 type ServiceOutput = TypeScriptFetchClientGeneratorOutput;
 type Context = TypeScriptFetchClientsGeneratorContext;
+/**
+ * Generates a fetch client class and/or client interface for each API service (tag).
+ *
+ * Each service produces `{outputDir}/{clientDir}/{service}-client.ts` (the class) and/or
+ * `{outputDir}/{clientInterfaceDir}/{service}.ts` (the interface), depending on `clientFileKind`, where `{service}` is
+ * the kebab-cased service name. The utilities are copied to `{outputDir}/{utilsDir}`. The index files
+ * `{outputDir}/{clientsIndexFile}` and `{outputDir}/{clientInterfacesIndexFile}` are written when they are configured.
+ *
+ * It publishes `typescript.clients[serviceId]` with the `client` and `clientInterface` exports of each service, and
+ * `typescript.indexFiles.clients` and `typescript.indexFiles.clientInterfaces` for subsequent generators.
+ * @see TypeScriptFetchClientGenerator
+ */
 export declare class TypeScriptFetchClientsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
     private readonly _clientGeneratorFactory;
+    /**
+     * Initializes a new instance of the TypeScriptFetchClientsGenerator class.
+     * @param clientGeneratorFactory The factory that creates the generator for each service. Defaults to a
+     * `DefaultTypeScriptFetchClientGenerator`.
+     */
     constructor(clientGeneratorFactory?: Factory<TypeScriptFetchClientGenerator, []>);
     protected initResult(): Output;
     protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;

package/dist/src/generators/services/fetch-clients/fetch-clients-generator.js

@@ -7,8 +7,25 @@ import { TypeScriptFileBuilder } from '../../../file-builder.js';
 import { DefaultTypeScriptFetchClientGenerator, } from './fetch-client-generator.js';
 import { defaultTypeScriptFetchClientsGeneratorConfig, } from './models.js';
 import { getReferenceFactories } from './refs.js';
+/**
+ * Generates a fetch client class and/or client interface for each API service (tag).
+ *
+ * Each service produces `{outputDir}/{clientDir}/{service}-client.ts` (the class) and/or
+ * `{outputDir}/{clientInterfaceDir}/{service}.ts` (the interface), depending on `clientFileKind`, where `{service}` is
+ * the kebab-cased service name. The utilities are copied to `{outputDir}/{utilsDir}`. The index files
+ * `{outputDir}/{clientsIndexFile}` and `{outputDir}/{clientInterfacesIndexFile}` are written when they are configured.
+ *
+ * It publishes `typescript.clients[serviceId]` with the `client` and `clientInterface` exports of each service, and
+ * `typescript.indexFiles.clients` and `typescript.indexFiles.clientInterfaces` for subsequent generators.
+ * @see TypeScriptFetchClientGenerator
+ */
 export class TypeScriptFetchClientsGenerator extends OpenApiServicesGenerationProviderBase {
     _clientGeneratorFactory;
+    /**
+     * Initializes a new instance of the TypeScriptFetchClientsGenerator class.
+     * @param clientGeneratorFactory The factory that creates the generator for each service. Defaults to a
+     * `DefaultTypeScriptFetchClientGenerator`.
+     */
     constructor(clientGeneratorFactory) {
         super();
         this._clientGeneratorFactory =

package/dist/src/generators/services/fetch-clients/models.d.ts

@@ -3,6 +3,11 @@ import type { TypeScriptExportOutput } from '../../../common-results.ts';
 import { type TypeScriptGeneratorConfig } from '../../../config.ts';
 import type { TypeScriptModelsGeneratorOutput } from '../../models/models.ts';
 import type { getReferenceFactories } from './refs.ts';
+/**
+ * The configuration of the `TypeScriptFetchClientsGenerator`. It extends the common TypeScript generator configuration
+ * with the naming, directory and index file settings of the generated clients and client interfaces.
+ * @see TypeScriptFetchClientsGenerator
+ */
 export type TypeScriptFetchClientsGeneratorConfig = TypeScriptGeneratorConfig & {
     /**
      * The casing of the client file names. If nullish, the `fileNameCasing` is used.
@@ -11,7 +16,7 @@ export type TypeScriptFetchClientsGeneratorConfig = TypeScriptGeneratorConfig &
     clientFileNameCasing: Nullable<ExtendedStringCasing>;
     /**
      * The casing of the client interface file names. If nullish, the `fileNameCasing` is used.
-     * @default { casing: 'kebab', suffix: '-client' }
+     * @default undefined
      */
     clientInterfaceFileNameCasing: Nullable<ExtendedStringCasing>;
     /**
@@ -58,26 +63,84 @@ export type TypeScriptFetchClientsGeneratorConfig = TypeScriptGeneratorConfig &
      */
     utilsDir: string;
 };
+/**
+ * The default configuration of the `TypeScriptFetchClientsGenerator`. The provider uses these values for every option
+ * that is not set in its configuration.
+ * @see TypeScriptFetchClientsGeneratorConfig
+ */
 export declare const defaultTypeScriptFetchClientsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptFetchClientsGeneratorConfig>;
+/**
+ * The input of the `TypeScriptFetchClientsGenerator`. It is the output of the models generator, which the generated
+ * clients use to reference the request and response model types.
+ * @see TypeScriptModelsGeneratorOutput
+ */
 export type TypeScriptFetchClientsGeneratorInput = TypeScriptModelsGeneratorOutput;
+/**
+ * The output of the `TypeScriptFetchClientsGenerator`. It is published under the `typescript` key for subsequent
+ * generators.
+ * @see TypeScriptFetchClientGeneratorOutput
+ */
 export type TypeScriptFetchClientsGeneratorOutput = {
+    /**
+     * The TypeScript-specific results of the fetch clients generator.
+     */
     typescript: {
+        /**
+         * The clients, keyed by the ID of their service (`ApiService['id']`).
+         */
         clients: {
+            /**
+             * The client and client interface that were generated for one service.
+             */
             [serviceId: string]: TypeScriptFetchClientGeneratorOutput;
         };
+        /**
+         * The paths of the index files. A value is `null` when its index file is disabled by the configuration.
+         */
         indexFiles: {
+            /**
+             * The path to the index file that exports the client classes.
+             */
             clients: Nullable<string>;
+            /**
+             * The path to the index file that exports the client interfaces.
+             */
             clientInterfaces: Nullable<string>;
         };
     };
 };
+/**
+ * The output of the `TypeScriptFetchClientGenerator` for one service. A property is only set when `clientFileKind`
+ * generates its kind of file.
+ */
 export type TypeScriptFetchClientGeneratorOutput = {
+    /**
+     * The exported client class and the file it was written to. Set when `clientFileKind` generates the class.
+     */
     client?: TypeScriptExportOutput;
+    /**
+     * The exported client interface and the file it was written to. Set when `clientFileKind` generates the interface.
+     */
     clientInterface?: TypeScriptExportOutput;
 };
+/**
+ * The context passed to the `TypeScriptFetchClientsGenerator` methods. It extends the services generator context with
+ * the reference factories of the generated clients.
+ * @see TypeScriptFetchClientGeneratorContext
+ */
 export type TypeScriptFetchClientsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptFetchClientsGeneratorInput, TypeScriptFetchClientsGeneratorOutput, TypeScriptFetchClientsGeneratorConfig, TypeScriptFetchClientGeneratorOutput> & {
+    /**
+     * The factories that create references to the utilities, as returned by `getReferenceFactories`.
+     */
     refs: ReturnType<typeof getReferenceFactories>;
 };
+/**
+ * The context passed to `TypeScriptFetchClientGenerator.generate` for a single service.
+ * @see TypeScriptFetchClientsGeneratorContext
+ */
 export type TypeScriptFetchClientGeneratorContext = TypeScriptFetchClientsGeneratorContext & {
+    /**
+     * The API service whose client is generated.
+     */
     readonly service: ApiService;
 };

package/dist/src/generators/services/fetch-clients/models.js

@@ -1,4 +1,9 @@
 import { defaultTypeScriptGeneratorConfig } from '../../../config.js';
+/**
+ * The default configuration of the `TypeScriptFetchClientsGenerator`. The provider uses these values for every option
+ * that is not set in its configuration.
+ * @see TypeScriptFetchClientsGeneratorConfig
+ */
 export const defaultTypeScriptFetchClientsGeneratorConfig = {
     ...defaultTypeScriptGeneratorConfig,
     clientFileNameCasing: { casing: 'kebab', suffix: '-client' },

package/dist/src/generators/services/fetch-clients/refs.d.ts

@@ -1,5 +1,12 @@
 import { ts } from '../../../ast/index.ts';
 import type { TypeScriptFetchClientsGeneratorConfig } from './models.ts';
+/**
+ * Creates the references to the utilities that the generated fetch clients import from the `utils` directory.
+ * `TypeScriptFetchClientsGenerator` copies these utilities to `{outputDir}/{utilsDir}`.
+ * @param options The configuration of the fetch clients generator, which provides `outputDir` and `utilsDir`.
+ * @returns The reference factories for `TypedResponse`, `FetchClientOptions` and `UrlBuilder`, all imported from
+ * `fetch-client.utils.ts`.
+ */
 export declare function getReferenceFactories(options: TypeScriptFetchClientsGeneratorConfig): {
     typedResponse: ts.GenericModuleReferenceFactory<1>;
     fetchClientOptions: ts.ModuleReferenceFactory;

package/dist/src/generators/services/fetch-clients/refs.js

@@ -1,5 +1,12 @@
 import { resolve } from 'node:path';
 import { ts } from '../../../ast/index.js';
+/**
+ * Creates the references to the utilities that the generated fetch clients import from the `utils` directory.
+ * `TypeScriptFetchClientsGenerator` copies these utilities to `{outputDir}/{utilsDir}`.
+ * @param options The configuration of the fetch clients generator, which provides `outputDir` and `utilsDir`.
+ * @returns The reference factories for `TypedResponse`, `FetchClientOptions` and `UrlBuilder`, all imported from
+ * `fetch-client.utils.ts`.
+ */
 // See packages/typescript/assets/client/fetch for reference
 export function getReferenceFactories(options) {
     const utilsDirPath = resolve(options.outputDir, options.utilsDir);

package/dist/src/generators/services/k6-clients/k6-client-generator.d.ts

@@ -8,10 +8,31 @@ import type { TypeScriptK6ClientGeneratorContext, TypeScriptK6ClientGeneratorOut
 type Context = TypeScriptK6ClientGeneratorContext;
 type Output = TypeScriptK6ClientGeneratorOutput;
 type Builder = TypeScriptFileBuilder;
+/**
+ * Generates the k6 client class and the response models of one API service.
+ * @template TOutput The type of the output returned for the service.
+ * @see DefaultTypeScriptK6ClientGenerator
+ */
 export interface TypeScriptK6ClientGenerator<TOutput extends Output = Output> {
+    /**
+     * Generates the files of the service in the context and returns the exports that were written.
+     * @param context The context of the service to generate.
+     * @returns The output for the service, or a promise that resolves to it.
+     */
     generate(context: Context): MaybePromise<TOutput>;
 }
+/**
+ * The default implementation of `TypeScriptK6ClientGenerator`. It writes the client to
+ * `{outputDir}/{clientDir}/{service}-client.js` (or `.ts`, depending on `language`), and the response models of each
+ * endpoint to `{outputDir}/{responseModelsDir}/{service}-responses.ts`. Extend it to customize the output.
+ * @see TypeScriptK6ClientsGenerator
+ */
 export declare class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptK6ClientGenerator {
+    /**
+     * Generates the response models and the client file of the service and returns their exports.
+     * @param ctx The context of the service to generate.
+     * @returns The client `component` and `filePath`, and the `responseModels` keyed by endpoint ID.
+     */
     generate(ctx: TypeScriptK6ClientGeneratorContext): MaybePromise<TypeScriptK6ClientGeneratorOutput>;
     protected generateResponseModels(ctx: Context): Record<string, TypeScriptExportOutput>;
     protected getResponseModelFileContent(ctx: Context, endpoint: ApiEndpoint): AppendValueGroup<Builder>;

package/dist/src/generators/services/k6-clients/k6-client-generator.js

@@ -4,7 +4,18 @@ import { ts } from '../../../ast/index.js';
 import { TypeScriptFileBuilder } from '../../../file-builder.js';
 import { getSourceDocLine } from '../../../utils.js';
 import { TypeScriptFileGenerator } from '../../file-generator.js';
+/**
+ * The default implementation of `TypeScriptK6ClientGenerator`. It writes the client to
+ * `{outputDir}/{clientDir}/{service}-client.js` (or `.ts`, depending on `language`), and the response models of each
+ * endpoint to `{outputDir}/{responseModelsDir}/{service}-responses.ts`. Extend it to customize the output.
+ * @see TypeScriptK6ClientsGenerator
+ */
 export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator {
+    /**
+     * Generates the response models and the client file of the service and returns their exports.
+     * @param ctx The context of the service to generate.
+     * @returns The client `component` and `filePath`, and the `responseModels` keyed by endpoint ID.
+     */
     generate(ctx) {
         const responseModels = this.generateResponseModels(ctx);
         const filePath = this.getFilePath(ctx);

package/dist/src/generators/services/k6-clients/k6-clients-generator.d.ts

@@ -7,8 +7,26 @@ type Output = TypeScriptK6ClientsGeneratorOutput;
 type Config = TypeScriptK6ClientsGeneratorConfig;
 type ServiceOutput = TypeScriptK6ClientGeneratorOutput;
 type Context = TypeScriptK6ClientsGeneratorContext;
+/**
+ * Generates a k6 client class for each API service (tag), plus index files for the clients and the response models.
+ *
+ * Each service produces `{outputDir}/{clientDir}/{service}-client.js` (or `.ts`, depending on `language`) and its
+ * response models in `{outputDir}/{responseModelsDir}/{service}-responses.ts`, where `{service}` is the kebab-cased
+ * service name. The request builder is copied to `{outputDir}/{utilsDir}`, and `http-status-code.ts` is generated there
+ * when `strictResponseTypes` is disabled. The index files `{outputDir}/{clientsIndexFile}` and
+ * `{outputDir}/{responseModelsIndexFile}` are written when they are configured.
+ *
+ * It publishes `typescript.k6Clients[serviceId]` with the client `component` and `filePath` and the `responseModels`
+ * of each service, and `typescript.indexFiles.k6Clients` and `typescript.indexFiles.k6ResponseModels`.
+ * @see TypeScriptK6ClientGenerator
+ */
 export declare class TypeScriptK6ClientsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
     private readonly _clientGeneratorFactory;
+    /**
+     * Initializes a new instance of the TypeScriptK6ClientsGenerator class.
+     * @param clientGeneratorFactory The factory that creates the generator for each service. Defaults to a
+     * `DefaultTypeScriptK6ClientGenerator`.
+     */
     constructor(clientGeneratorFactory?: Factory<TypeScriptK6ClientGenerator, []>);
     protected initResult(): Output;
     protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;

package/dist/src/generators/services/k6-clients/k6-clients-generator.js

@@ -7,8 +7,26 @@ import { TypeScriptFileBuilder } from '../../../file-builder.js';
 import { DefaultTypeScriptK6ClientGenerator } from './k6-client-generator.js';
 import { defaultTypeScriptK6ClientsGeneratorConfig, } from './models.js';
 import { getReferenceFactories } from './refs.js';
+/**
+ * Generates a k6 client class for each API service (tag), plus index files for the clients and the response models.
+ *
+ * Each service produces `{outputDir}/{clientDir}/{service}-client.js` (or `.ts`, depending on `language`) and its
+ * response models in `{outputDir}/{responseModelsDir}/{service}-responses.ts`, where `{service}` is the kebab-cased
+ * service name. The request builder is copied to `{outputDir}/{utilsDir}`, and `http-status-code.ts` is generated there
+ * when `strictResponseTypes` is disabled. The index files `{outputDir}/{clientsIndexFile}` and
+ * `{outputDir}/{responseModelsIndexFile}` are written when they are configured.
+ *
+ * It publishes `typescript.k6Clients[serviceId]` with the client `component` and `filePath` and the `responseModels`
+ * of each service, and `typescript.indexFiles.k6Clients` and `typescript.indexFiles.k6ResponseModels`.
+ * @see TypeScriptK6ClientGenerator
+ */
 export class TypeScriptK6ClientsGenerator extends OpenApiServicesGenerationProviderBase {
     _clientGeneratorFactory;
+    /**
+     * Initializes a new instance of the TypeScriptK6ClientsGenerator class.
+     * @param clientGeneratorFactory The factory that creates the generator for each service. Defaults to a
+     * `DefaultTypeScriptK6ClientGenerator`.
+     */
     constructor(clientGeneratorFactory) {
         super();
         this._clientGeneratorFactory =

package/dist/src/generators/services/k6-clients/models.d.ts

@@ -5,6 +5,11 @@ import { type TypeScriptGeneratorConfig } from '../../../config.ts';
 import type { TypeScriptFileBuilder } from '../../../file-builder.ts';
 import type { TypeScriptModelsGeneratorOutput } from '../../models/index.ts';
 import type { getReferenceFactories } from './refs.ts';
+/**
+ * The configuration of the `TypeScriptK6ClientsGenerator`. It extends the common TypeScript generator configuration
+ * with the language, response type, naming, directory and index file settings of the generated k6 clients.
+ * @see TypeScriptK6ClientsGenerator
+ */
 export type TypeScriptK6ClientsGeneratorConfig = TypeScriptGeneratorConfig & {
     /**
      * The language of the generated clients.
@@ -78,7 +83,7 @@ export type TypeScriptK6ClientsGeneratorConfig = TypeScriptGeneratorConfig & {
     responseModelsDir: string;
     /**
      * The index file where all clients should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
-     * @default 'clients.ts'
+     * @default 'clients.js'
      */
     clientsIndexFile: Nullable<string>;
     /**
@@ -97,27 +102,86 @@ export type TypeScriptK6ClientsGeneratorConfig = TypeScriptGeneratorConfig & {
      */
     async: boolean;
 };
+/**
+ * The default configuration of the `TypeScriptK6ClientsGenerator`. The provider uses these values for every option that
+ * is not set in its configuration.
+ * @see TypeScriptK6ClientsGeneratorConfig
+ */
 export declare const defaultTypeScriptK6ClientsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptK6ClientsGeneratorConfig>;
+/**
+ * The input of the `TypeScriptK6ClientsGenerator`. It is the output of the models generator, which the clients use to
+ * reference the request and response model types.
+ * @see TypeScriptModelsGeneratorOutput
+ */
 export type TypeScriptK6ClientsGeneratorInput = TypeScriptModelsGeneratorOutput;
+/**
+ * The output of the `TypeScriptK6ClientsGenerator`. It is published under the `typescript` key for subsequent
+ * generators.
+ * @see TypeScriptK6ClientGeneratorOutput
+ */
 export type TypeScriptK6ClientsGeneratorOutput = {
+    /**
+     * The TypeScript-specific results of the k6 clients generator.
+     */
     typescript: {
+        /**
+         * The clients, keyed by the ID of their service (`ApiService['id']`).
+         */
         k6Clients: {
+            /**
+             * The client and response models that were generated for one service.
+             */
             [serviceId: string]: TypeScriptK6ClientGeneratorOutput;
         };
+        /**
+         * The paths of the index files. A value is `null` when its index file is disabled by the configuration.
+         */
         indexFiles: {
+            /**
+             * The path to the index file that exports the client classes.
+             */
             k6Clients: Nullable<string>;
+            /**
+             * The path to the index file that exports the response model types.
+             */
             k6ResponseModels: Nullable<string>;
         };
     };
 };
+/**
+ * The output of the `TypeScriptK6ClientGenerator` for one service: the exported client class and its file, plus the
+ * response model types of its endpoints.
+ * @see TypeScriptExportOutput
+ */
 export type TypeScriptK6ClientGeneratorOutput = TypeScriptExportOutput & {
+    /**
+     * The response model types of the service, keyed by the ID of their endpoint (`ApiEndpoint['id']`).
+     */
     responseModels: {
+        /**
+         * The exported response model type and the file it was written to.
+         */
         [operationId: string]: TypeScriptExportOutput;
     };
 };
+/**
+ * The context passed to the `TypeScriptK6ClientsGenerator` methods. It extends the services generator context with the
+ * reference factories of the generated clients.
+ * @see TypeScriptK6ClientGeneratorContext
+ */
 export type TypeScriptK6ClientsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptK6ClientsGeneratorInput, TypeScriptK6ClientsGeneratorOutput, TypeScriptK6ClientsGeneratorConfig, TypeScriptK6ClientGeneratorOutput> & {
+    /**
+     * The factories that create references to the utilities, as returned by `getReferenceFactories`.
+     */
     refs: ReturnType<typeof getReferenceFactories>;
 };
+/**
+ * The context passed to `TypeScriptK6ClientGenerator.generate` for a single service.
+ * @see TypeScriptK6ClientsGeneratorContext
+ */
 export type TypeScriptK6ClientGeneratorContext = TypeScriptK6ClientsGeneratorContext & {
+    /**
+     * The API service whose client is generated.
+     */
     readonly service: ApiService;
 };

package/dist/src/generators/services/k6-clients/models.js

@@ -1,4 +1,9 @@
 import { defaultTypeScriptGeneratorConfig } from '../../../config.js';
+/**
+ * The default configuration of the `TypeScriptK6ClientsGenerator`. The provider uses these values for every option that
+ * is not set in its configuration.
+ * @see TypeScriptK6ClientsGeneratorConfig
+ */
 export const defaultTypeScriptK6ClientsGeneratorConfig = {
     ...defaultTypeScriptGeneratorConfig,
     language: 'javascript',

package/dist/src/generators/services/k6-clients/refs.d.ts

@@ -1,5 +1,13 @@
 import { ts } from '../../../ast/index.ts';
 import type { TypeScriptK6ClientsGeneratorConfig } from './models.ts';
+/**
+ * Creates the references to the utilities that the generated k6 clients import from the `utils` directory.
+ * `TypeScriptK6ClientsGenerator` copies the request builder there, and generates `http-status-code.ts` when
+ * `strictResponseTypes` is disabled.
+ * @param options The configuration of the k6 clients generator, which provides `outputDir`, `utilsDir` and `language`.
+ * @returns The reference factories for `RequestBuilder` (`request-builder.js` or `.ts`, depending on `language`) and
+ * for `HttpStatusCode` (`http-status-code.ts`).
+ */
 export declare function getReferenceFactories(options: TypeScriptK6ClientsGeneratorConfig): {
     requestBuilder: ts.ModuleReferenceFactory;
     httpStatusCode: ts.ModuleReferenceFactory;

package/dist/src/generators/services/k6-clients/refs.js

@@ -1,5 +1,13 @@
 import { join, resolve } from 'node:path';
 import { ts } from '../../../ast/index.js';
+/**
+ * Creates the references to the utilities that the generated k6 clients import from the `utils` directory.
+ * `TypeScriptK6ClientsGenerator` copies the request builder there, and generates `http-status-code.ts` when
+ * `strictResponseTypes` is disabled.
+ * @param options The configuration of the k6 clients generator, which provides `outputDir`, `utilsDir` and `language`.
+ * @returns The reference factories for `RequestBuilder` (`request-builder.js` or `.ts`, depending on `language`) and
+ * for `HttpStatusCode` (`http-status-code.ts`).
+ */
 export function getReferenceFactories(options) {
     const utilsDirPath = resolve(options.outputDir, options.utilsDir);
     const ext = options.language === 'javascript' ? '.js' : '.ts';

package/dist/src/import-collection.d.ts

@@ -1,18 +1,60 @@
 import { type SourceBuilderOptions, StringBuilder } from '@goast/core';
 import type { TypeScriptExportType, TypeScriptImport, TypeScriptImportKind, TypeScriptImportType } from './common-results.ts';
 import { type ImportModuleTransformer } from './utils.ts';
+/**
+ * The options of an `ImportExportCollection`.
+ */
 export type ImportExportCollectionOptions = {
+    /**
+     * The path of the file that the statements are written to. Paths of project files are made relative to it. If it is
+     * omitted, file paths are written as they are.
+     */
     filePath?: string;
+    /**
+     * The transformer that writes the relative module paths of project files.
+     * @default 'omit-extension'
+     */
     importModuleTransformer: ImportModuleTransformer;
+    /**
+     * Whether the module paths are quoted with single quotes instead of double quotes.
+     * @default true
+     */
     useSingleQuotes: boolean;
 };
+/**
+ * The default options of an `ImportExportCollection`. The transformer and the quote style are taken from
+ * `defaultTypeScriptGeneratorConfig`.
+ */
 export declare const defaultImportExportCollectionOptions: ImportExportCollectionOptions;
+/**
+ * The options of an import that is added with `addImport`. Its `type` property sets the form of the import statement,
+ * see `TypeScriptImportType`, and defaults to `'import'`.
+ */
 export type TypeScriptImportOptions = {
     type?: TypeScriptImportType;
 };
+/**
+ * The options of an export that is added with `addExport`. Its `type` property sets the form of the export statement,
+ * see `TypeScriptExportType`, and defaults to `'export'`.
+ */
 export type TypeScriptExportOptions = {
     type?: TypeScriptExportType;
 };
+/**
+ * Collects the imports and re-exports of a file, and writes them as import and export statements.
+ *
+ * Names are stored per module path, in one map for each form: `import`, `import type` and `@import` names, and the same
+ * for re-exports. Adding a name that is already present has no effect, so each name is written once per module.
+ *
+ * When the statements are written, a project file (a path ending in `.ts`, `.js` or `.json`) is turned into a relative
+ * path from the file that the statements are written to, and transformed with `importModuleTransformer`. A package
+ * name, such as `rxjs`, is written as it is. The statements are written in this order: value imports, type imports, the
+ * `@import` block, value re-exports and type re-exports. Module imports come before file imports, separated by a blank
+ * line.
+ *
+ * `TypeScriptFileBuilder` owns one of these collections. It adds the imports of every `TsReference` node that has a
+ * module or file path, and it passes its own `filePath` and options to the collection.
+ */
 export declare class ImportExportCollection {
     private readonly _imports;
     private readonly _typeImports;
@@ -20,15 +62,54 @@ export declare class ImportExportCollection {
     private readonly _exports;
     private readonly _typeExports;
     private readonly _options;
+    /**
+     * Initializes a new instance of the ImportExportCollection class.
+     * @param options The options of the collection. Options that are not given use the defaults.
+     */
     constructor(options?: Partial<ImportExportCollectionOptions>);
+    /**
+     * Gets a value indicating whether at least one import of any form has been added.
+     */
     get hasImports(): boolean;
+    /**
+     * Gets a value indicating whether at least one re-export of any form has been added.
+     */
     get hasExports(): boolean;
+    /**
+     * Gets all collected imports as a flat list. The module paths are the unresolved ones, as they were passed to
+     * `addImport`, so they are not yet relative to the file.
+     */
     get imports(): TypeScriptImport[];
     private toImport;
+    /**
+     * Adds a named import from a module or a file. Adding the same name from the same module again has no effect.
+     * @param importName The name to import.
+     * @param fromModule The module name, such as `rxjs`, or the path of the file that exports the name.
+     * @param options The options of the import, such as the import type. Defaults to a value import.
+     */
     addImport(importName: string, fromModule: string, options?: TypeScriptImportOptions): void;
+    /**
+     * Adds a named re-export from a module or a file. Adding the same name from the same module again has no effect.
+     * @param exportName The name to re-export.
+     * @param fromModule The module name, or the path of the file that exports the name.
+     * @param options The options of the export, such as the export type. Defaults to a value export.
+     */
     addExport(exportName: string, fromModule: string, options?: TypeScriptExportOptions): void;
+    /**
+     * Removes all collected imports and re-exports.
+     */
     clear(): void;
+    /**
+     * Renders the import and export statements as a string.
+     * @param options The options of the builder that the statements are written with.
+     * @returns The import and export statements.
+     */
     toString(options: Partial<SourceBuilderOptions>): string;
+    /**
+     * Writes the import and export statements to a builder. The statements are written in the order described for the
+     * class, and the groups are separated by a blank line.
+     * @param builder The builder to write the statements to.
+     */
     writeTo(builder: StringBuilder): void;
     protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export' | 'import type' | 'export type' | ' * @import', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
         useSingleQuotes: boolean;