@kubb/swagger-ts 1.12.0-canary.20231012T112940 → 1.12.0-canary.20231013T141355

package/dist/index.d.cts

@@ -0,0 +1,161 @@
+import * as _kubb_core from '@kubb/core';
+import { PluginFactoryOptions, SchemaGenerator, PluginContext, File, PathMode } from '@kubb/core';
+import { SkipBy, ResolvePathOptions, OpenAPIV3, Refs, OperationGenerator as OperationGenerator$1, Operation, Resolver, OperationSchemas, Oas, ContentType, OasBuilder, FileResolver, ResolveProps } from '@kubb/swagger';
+import ts from 'typescript';
+import { Options as Options$3 } from 'change-case';
+
+type Options$2 = {
+    /**
+     * Relative path to save the TypeScript types.
+     * When output is a file it will save all models inside that file else it will create a file per schema item.
+     * @default 'models'
+     */
+    output?: string;
+    /**
+     * Group the TypeScript types based on the provided name.
+     */
+    groupBy?: {
+        /**
+         * Tag will group based on the operation tag inside the Swagger file.
+         */
+        type: 'tag';
+        /**
+         * Relative path to save the grouped TypeScript Types.
+         *
+         * `{{tag}}` will be replaced by the current tagName.
+         * @example `${output}/{{tag}}Controller` => `models/PetController`
+         * @default `${output}/{{tag}}Controller`
+         */
+        output?: string;
+    };
+    skipBy?: SkipBy[];
+    /**
+     * Choose to use `enum` or `as const` for enums
+     * @default 'asConst'
+     */
+    enumType?: 'enum' | 'asConst' | 'asPascalConst';
+    /**
+     * Choose to use `date` or `datetime` as JavaScript `Date` instead of `string`.
+     * @default 'string'
+     */
+    dateType?: 'string' | 'date';
+    /**
+     * Choose what to use as mode for an optional value.
+     * @examples 'questionToken': type?: string
+     * @examples 'undefined': type: string | undefined
+     * @examples 'questionTokenAndUndefined': type?: string | undefined
+     * @default 'questionToken'
+     */
+    optionalType?: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
+    transformers?: {
+        /**
+         * Override the name of the TypeScript type that is getting generated, this will also override the name of the file.
+         */
+        name?: (name: string) => string;
+    };
+};
+type FileMeta = {
+    pluginName?: string;
+    tag?: string;
+};
+type PluginOptions = PluginFactoryOptions<'swagger-ts', Options$2, false, unknown, ResolvePathOptions>;
+
+declare const pluginName: PluginOptions['name'];
+declare const definePlugin: (options: Options$2) => _kubb_core.KubbUserPlugin<PluginOptions>;
+
+type Options$1 = {
+    withJSDocs?: boolean;
+    resolveName: PluginContext['resolveName'];
+    enumType: 'enum' | 'asConst' | 'asPascalConst';
+    dateType: 'string' | 'date';
+    optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
+};
+declare class TypeGenerator extends SchemaGenerator<Options$1, OpenAPIV3.SchemaObject, ts.Node[]> {
+    static usedEnumNames: Record<string, number>;
+    refs: Refs;
+    extraNodes: ts.Node[];
+    aliases: ts.TypeAliasDeclaration[];
+    usedAliasNames: Record<string, number>;
+    caseOptions: Options$3;
+    constructor(options?: Options$1);
+    build({ schema, baseName, description }: {
+        schema: OpenAPIV3.SchemaObject;
+        baseName: string;
+        description?: string;
+    }): ts.Node[];
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    private getTypeFromSchema;
+    /**
+     * Recursively creates a type literal with the given props.
+     */
+    private getTypeFromProperties;
+    /**
+     * Create a type alias for the schema referenced by the given ReferenceObject
+     */
+    private getRefAlias;
+    /**
+     * This is the very core of the OpenAPI to TS conversion - it takes a
+     * schema and returns the appropriate type.
+     */
+    private getBaseTypeFromSchema;
+}
+
+type Options = {
+    oas: Oas;
+    contentType?: ContentType;
+    skipBy?: SkipBy[];
+    resolvePath: PluginContext['resolvePath'];
+    resolveName: PluginContext['resolveName'];
+    mode: PathMode;
+    enumType: 'enum' | 'asConst' | 'asPascalConst';
+    dateType: 'string' | 'date';
+    optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
+};
+declare class OperationGenerator extends OperationGenerator$1<Options> {
+    resolve(operation: Operation): Resolver;
+    all(): Promise<File | null>;
+    get(operation: Operation, schemas: OperationSchemas): Promise<File<FileMeta> | null>;
+    post(operation: Operation, schemas: OperationSchemas): Promise<File<FileMeta> | null>;
+    put(operation: Operation, schemas: OperationSchemas): Promise<File<FileMeta> | null>;
+    patch(operation: Operation, schemas: OperationSchemas): Promise<File<FileMeta> | null>;
+    delete(operation: Operation, schemas: OperationSchemas): Promise<File<FileMeta> | null>;
+}
+
+type Config = {
+    resolveName: PluginContext['resolveName'];
+    fileResolver?: FileResolver;
+    withJSDocs?: boolean;
+    withImports?: boolean;
+    enumType: 'enum' | 'asConst' | 'asPascalConst';
+    dateType: 'string' | 'date';
+    optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
+};
+declare class TypeBuilder extends OasBuilder<Config> {
+    configure(config: Config): this;
+    print(name?: string): string;
+}
+
+declare const keywordTypeNodes: {
+    readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
+    readonly number: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+    readonly integer: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+    readonly object: ts.KeywordTypeNode<ts.SyntaxKind.ObjectKeyword>;
+    readonly string: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
+    readonly boolean: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
+    readonly undefined: ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword>;
+    readonly null: ts.LiteralTypeNode;
+};
+
+type Props$1 = ResolveProps & {
+    pluginName?: never;
+};
+declare function resolve(props: Props$1): Resolver;
+
+type Props = Omit<Parameters<typeof resolve>[0], 'operation'>;
+declare function useResolve(props: Props): Resolver;
+
+export { FileMeta, OperationGenerator, Options$2 as Options, PluginOptions, TypeBuilder, TypeGenerator, definePlugin as default, definePlugin, keywordTypeNodes, pluginName, resolve, useResolve };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/swagger-ts",
-  "version": "1.12.0-canary.20231012T112940",
+  "version": "1.12.0-canary.20231013T141355",
   "description": "Generator swagger-ts",
   "keywords": [
     "typescript",
@@ -21,7 +21,6 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
@@ -40,9 +39,9 @@
   "dependencies": {
     "change-case": "^4.1.2",
     "typescript": "^5.2.2",
-    "@kubb/core": "1.11.0",
-    "@kubb/parser": "1.11.0",
-    "@kubb/swagger": "1.12.0-canary.20231012T112846"
+    "@kubb/core": "1.12.0-canary.20231013T141339",
+    "@kubb/parser": "1.12.0-canary.20231013T141212",
+    "@kubb/swagger": "1.11.2"
   },
   "devDependencies": {
     "eslint": "^8.51.0",