swagger-typescript-api 13.2.7 → 13.2.9

package/dist/lib.d.cts

@@ -1,11 +1,9 @@
 import { OpenAPI } from "openapi-types";
-import * as typescript$1 from "typescript";
 import * as typescript from "typescript";
-import * as lodash19 from "lodash";
-import * as lodash14 from "lodash";
+import * as lodash0 from "lodash";
 import lodash from "lodash";
-import * as swagger_schema_official16 from "swagger-schema-official";
-import * as eta20 from "eta";
+import * as swagger_schema_official0 from "swagger-schema-official";
+import * as eta0 from "eta";
 
 //#region rolldown:runtime
 //#endregion
@@ -381,7 +379,7 @@ declare class JavascriptTranslator extends Translator {
   compileTSCode: (input: TranslatorIO) => Record<string, string>;
   translate: (input: any) => Promise<{
     fileName: any;
-    fileExtension: typescript$1.Extension;
+    fileExtension: typescript.Extension;
     fileContent: string;
   }[]>;
 }
@@ -530,7 +528,7 @@ declare class CodeGenProcess {
         }) => string;
         NameResolver: typeof NameResolver;
         _: lodash.LoDashStatic;
-        require: (packageOrPath: string) => Promise<any>;
+        require: (packageOrPath: string) => any;
       };
     };
     getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
@@ -635,7 +633,7 @@ declare class CodeGenProcess {
       }) => string;
       NameResolver: typeof NameResolver;
       _: lodash.LoDashStatic;
-      require: (packageOrPath: string) => Promise<any>;
+      require: (packageOrPath: string) => any;
     };
     config: CodeGenConfig;
   };
@@ -672,7 +670,7 @@ declare class TemplatesWorker {
   getTemplatePaths: (config: CodeGenConfig) => CodeGenConfig["templatePaths"];
   cropExtension: (path: string) => string;
   getTemplateFullPath: (path_: string, fileName: string) => string | undefined;
-  requireFnFromTemplate: (packageOrPath: string) => Promise<any>;
+  requireFnFromTemplate: (packageOrPath: string) => any;
   getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
   getTemplates: ({
     templatePaths
@@ -776,6 +774,54 @@ declare class MonoSchemaParser {
 //#endregion
 //#region types/index.d.ts
 type HttpClientType = (typeof HTTP_CLIENT)[keyof typeof HTTP_CLIENT];
+type CodeGenConstruct = {
+  Keyword: {
+    Number: string;
+    String: string;
+    Boolean: string;
+    Any: string;
+    Void: string;
+    Unknown: string;
+    Null: string;
+    Undefined: string;
+    Object: string;
+    File: string;
+    Date: string;
+    Type: string;
+    Enum: string;
+    Interface: string;
+    Array: string;
+    Record: string;
+    Intersection: string;
+    Union: string;
+  };
+  CodeGenKeyword: {
+    UtilRequiredKeys: string;
+  };
+  ArrayType: (content: unknown) => string;
+  StringValue: (content: unknown) => string;
+  BooleanValue: (content: unknown) => string;
+  NumberValue: (content: unknown) => string;
+  NullValue: (content: unknown) => string;
+  UnionType: (content: unknown) => string;
+  ExpressionGroup: (content: unknown) => string;
+  IntersectionType: (content: unknown) => string;
+  RecordType: (content: unknown) => string;
+  TypeField: (content: unknown) => string;
+  InterfaceDynamicField: (content: unknown) => string;
+  EnumUsageKey: (enumStruct: unknown, key: unknown) => string;
+  EnumField: (content: unknown) => string;
+  EnumFieldDescription: (content: unknown) => string;
+  EnumFieldsWrapper: (content: unknown) => string;
+  ObjectWrapper: (content: unknown) => string;
+  MultilineComment: (content: unknown) => string;
+  TypeWithGeneric: (content: unknown) => string;
+  Tuple: (content: unknown) => string;
+};
+type PrimitiveTypeStructValue = string | ((schema: Record<string, unknown>, parser: SchemaParser) => string);
+type PrimitiveTypeStruct = Record<"integer" | "number" | "boolean" | "object" | "file" | "string" | "array", string | ({
+  $default: PrimitiveTypeStructValue;
+} & Record<string, PrimitiveTypeStructValue>)>;
 type BuildRouteParam = {
   /** {bar} */
   $match: string;
@@ -911,7 +957,7 @@ type RawRouteInfo = {
   description?: string;
   tags?: string[];
   summary?: string;
-  responses?: swagger_schema_official16.Spec["responses"];
+  responses?: swagger_schema_official0.Spec["responses"];
   produces?: string[];
   requestBody?: object;
   consumes?: string[];
@@ -1014,18 +1060,45 @@ type ExtractingOptions = {
 };
 interface GenerateApiConfiguration {
   apiConfig: {
+    /** base url from schema */
     baseUrl: string;
+    /** document title */
     title: string;
+    /** document version */
     version: string;
+    /** description split into lines */
     description: string[];
+    /** flag that description is present */
     hasDescription: boolean;
   };
   config: {
+    /** path to swagger schema */
     input: string;
+    /**
+     * generate separated files for http client, data contracts, and routes
+     * @default false
+     */
+    modular: boolean;
+    /**
+     * path to folder where the created api module will be placed.
+     * may be set to `false` to skip writing content to disk; in this case
+     * the `files` array on the return value will contain the generated contents.
+     */
     output: string | false;
+    /** url to swagger schema */
     url: string;
+    /** swagger schema JSON */
     spec: unknown;
+    /**
+     * file name for the generated API module
+     * @default 'Api.ts'
+     */
     fileName: string;
+    /**
+     * path to folder containing custom templates
+     * @default ""
+     */
+    templates: string;
     templatePaths: {
       /** `templates/base` */
       base: string;
@@ -1038,66 +1111,176 @@ interface GenerateApiConfiguration {
       /** custom path to templates (`--templates`) */
       custom: string | null;
     };
+    /** authorisation token for private swagger schema access */
     authorizationToken?: string;
+    /** generate additional information about request responses and error typings */
     generateResponses: boolean;
+    /**
+     * use "default" response status code as success response.
+     * some swagger schemas treat "default" as a successful response.
+     */
     defaultResponseAsSuccess: boolean;
+    /** generate type definitions for API routes */
     generateRouteTypes: boolean;
+    /** generate an API client */
     generateClient: boolean;
+    /** generate all "enum" types as union types (T1 | T2 | TN) */
     generateUnionEnums: boolean;
+    /** parsed swagger schema */
     swaggerSchema: object;
+    /** original swagger schema */
     originalSchema: object;
+    /** map of schema component references */
     componentsMap: Record<string, SchemaComponent>;
+    /** flag indicating the schema was converted from Swagger 2.0 */
     convertedFromSwagger2: boolean;
+    /** determines which path index should be used for routes separation */
     moduleNameIndex: number;
+    /** use the first tag for the module name */
     moduleNameFirstTag: boolean;
+    /** extra templates */
     extraTemplates: {
       name: string;
       path: string;
     }[];
+    /** extract request params to data contract */
     extractRequestParams: boolean;
+    /** unwrap the data item from the response */
     unwrapResponseData: boolean;
+    /** sort data contracts in alphabetical order */
     sortTypes: boolean;
+    /** sort routes in alphabetical order */
     sortRoutes: boolean;
+    /** ability to send HttpClient instance to Api constructor */
     singleHttpClient: boolean;
+    /** prefix string value for type names */
     typePrefix: string;
+    /** suffix string value for type names */
     typeSuffix: string;
+    /** prefix string value for enum keys */
     enumKeyPrefix: string;
+    /** suffix string value for enum keys */
     enumKeySuffix: string;
+    /** fix up small errors in the swagger source definition */
     patch: boolean;
+    /** remove output directory before generating */
     cleanOutput: boolean;
+    /** output debug messages */
     debug: boolean;
+    /**
+     * generate array types as Array<Type>
+     * @default false
+     */
     anotherArrayType: boolean;
+    /** extract request body type to data contract */
     extractRequestBody: boolean;
+    /** generated http client type */
     httpClientType: "axios" | "fetch";
+    /** generate readonly properties */
     addReadonly: boolean;
+    /** customise primitive type mappings */
+    primitiveTypeConstructs?: (struct: PrimitiveTypeStruct) => Partial<PrimitiveTypeStruct>;
+    /** customise code generation constructs */
+    codeGenConstructs?: (struct: CodeGenConstruct) => Partial<CodeGenConstruct>;
+    /** extract response body type to data contract */
     extractResponseBody: boolean;
+    /** extract response error type to data contract */
     extractResponseError: boolean;
+    /** extract all enums from nested types/interfaces to `enum` construction */
     extractEnums: boolean;
+    /** extract all enums from inline interface/type content to typescript enum construction */
     extractResponses: boolean;
+    /**
+     * prefix string value needed to fix invalid type names
+     * @default "Type"
+     */
     fixInvalidTypeNamePrefix: string;
+    /**
+     * prefix string value needed to fix invalid enum keys
+     * @default "Value"
+     */
     fixInvalidEnumKeyPrefix: string;
+    /**
+     * default type for empty response schema
+     * @default "void"
+     */
     defaultResponseType: string;
+    /**
+     * generate js api module with declaration file
+     * @default false
+     */
     toJS: boolean;
+    /** disable throwing on a non-successful response */
     disableThrowOnError: boolean;
+    /**
+     * output only errors to console
+     * @default false
+     */
     silent: boolean;
+    /** hooks for customising the generation process */
     hooks: Partial<Hooks>;
+    /** use enum names as values */
     enumNamesAsValues: boolean;
+    /** package version */
     version: string;
+    /** ts compiler configuration object (for --to-js option) */
     compilerTsConfig: Record<string, unknown>;
+    /** enum key resolver name */
     enumKeyResolverName: string;
+    /** type name resolver name */
     typeNameResolverName: string;
+    /** specific argument name resolver name */
     specificArgNameResolverName: string;
+    /**
+     * custom ts->* translator
+     * do not use constructor args, just send class reference
+     */
     customTranslator?: new () => Translator;
+    /** internal constants */
+    constants: typeof constants_d_exports;
+    /** code generation constructs for TypeScript */
+    Ts: CodeGenConstruct;
+    /**
+     * swagger schema type -> typescript type
+     * https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
+     */
+    primitiveTypes: PrimitiveTypeStruct;
+    /** built-in template info */
+    templateInfos: {
+      name: string;
+      fileName: string;
+    }[];
+    /** supported template file extensions */
+    templateExtensions: string[];
+    /** range of HTTP status codes treated as success */
+    successResponseStatusRange: [number, number];
+    /** custom schema parsers */
+    schemaParsers?: {
+      complexOneOf?: MonoSchemaParser;
+      complexAllOf?: MonoSchemaParser;
+      complexAnyOf?: MonoSchemaParser;
+      complexNot?: MonoSchemaParser;
+      enum?: MonoSchemaParser;
+      object?: MonoSchemaParser;
+      complex?: MonoSchemaParser;
+      primitive?: MonoSchemaParser;
+      discriminator?: MonoSchemaParser;
+      array?: MonoSchemaParser;
+    };
+    /** internal options for templates */
     internalTemplateOptions: {
       addUtilRequiredKeysType: boolean;
     };
+    /** resolver for component type names */
     componentTypeNameResolver: ComponentTypeNameResolver;
+    /** generated file names */
     fileNames: {
       dataContracts: string;
       routeTypes: string;
       httpClient: string;
       outOfModuleApi: string;
     };
+    /** Record<templateName, templateContent> */
     templatesToRender: {
       api: string;
       dataContracts: string;
@@ -1110,10 +1293,16 @@ interface GenerateApiConfiguration {
       enumDataContract: string;
       objectFieldJsDoc: string;
     };
+    /** map of duplicate route names */
     routeNameDuplicatesMap: Map<string, string>;
+    /** name of the main exported class */
     apiClassName: string;
-    requestOptions?: RequestInit;
-    extractingOptions: ExtractingOptions;
+    /** configuration for fetching swagger schema requests */
+    requestOptions?: Partial<RequestInit>;
+    /** extra configuration for extracting type names operations */
+    extractingOptions: Partial<ExtractingOptions>;
+    /** update configuration object during generation */
+    update: (update: Partial<GenerateApiConfiguration["config"]>) => void;
   };
   modelTypes: ModelType[];
   hasFormDataRoutes: boolean;
@@ -1144,7 +1333,7 @@ interface GenerateApiConfiguration {
     fmtToJSDocLine: (line: string, params?: {
       eol?: boolean;
     }) => string;
-    _: lodash19.LoDashStatic;
+    _: lodash0.LoDashStatic;
     require: (path: string) => unknown;
   };
 }
@@ -1165,7 +1354,7 @@ interface GenerateApiOutput {
     content: string;
     withPrefix: boolean;
   }) => void;
-  renderTemplate: (templateContent: string, data: Record<string, unknown>, etaOptions?: Partial<eta20.EtaConfig>) => Promise<string> | string;
+  renderTemplate: (templateContent: string, data: Record<string, unknown>, etaOptions?: Partial<eta0.EtaConfig>) => Promise<string> | string;
   getTemplate: (params: {
     fileName?: string;
     name?: string;
@@ -1587,8 +1776,8 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
         eol?: boolean | undefined;
       }) => string;
       NameResolver: typeof NameResolver;
-      _: lodash14.LoDashStatic;
-      require: (packageOrPath: string) => Promise<any>;
+      _: lodash0.LoDashStatic;
+      require: (packageOrPath: string) => any;
     };
   };
   getTemplate: (name: string, fileName: string, path?: string) => string | undefined;