swagger-typescript-api
    Preparing search index...

    Function generateApi

    • Parameters

      • config: Partial<
            {
                addReadonly: boolean;
                anotherArrayType: boolean;
                apiClassName: string;
                authorizationToken?: string;
                cleanOutput: boolean;
                compilerTsConfig: Record<string, unknown>;
                componentsMap: Record<string, SchemaComponent>;
                componentTypeNameResolver: ComponentTypeNameResolver;
                convertedFromSwagger2: boolean;
                customTranslator?: new () => Translator;
                debug: boolean;
                defaultResponseAsSuccess: boolean;
                defaultResponseType: string;
                disableThrowOnError: boolean;
                enumKeyPrefix: string;
                enumKeyResolverName: string;
                enumKeySuffix: string;
                enumNamesAsValues: boolean;
                extractEnums: boolean;
                extractingOptions: ExtractingOptions;
                extractRequestBody: boolean;
                extractRequestParams: boolean;
                extractResponseBody: boolean;
                extractResponseError: boolean;
                extractResponses: boolean;
                extraTemplates: { name: string; path: string }[];
                fileName: string;
                fileNames: {
                    dataContracts: string;
                    httpClient: string;
                    outOfModuleApi: string;
                    routeTypes: string;
                };
                fixInvalidEnumKeyPrefix: string;
                fixInvalidTypeNamePrefix: string;
                generateClient: boolean;
                generateResponses: boolean;
                generateRouteTypes: boolean;
                generateUnionEnums: boolean;
                hooks: Partial<Hooks>;
                httpClientType: "axios" | "fetch";
                input: string;
                internalTemplateOptions: { addUtilRequiredKeysType: boolean };
                moduleNameFirstTag: boolean;
                moduleNameIndex: number;
                originalSchema: object;
                output: string | false;
                patch: boolean;
                requestOptions?: RequestInit;
                routeNameDuplicatesMap: Map<string, string>;
                silent: boolean;
                singleHttpClient: boolean;
                sortRoutes: boolean;
                sortTypes: boolean;
                spec: unknown;
                specificArgNameResolverName: string;
                swaggerSchema: object;
                templatePaths: {
                    base: string;
                    custom: null | string;
                    default: string;
                    modular: string;
                    original: string;
                };
                templatesToRender: {
                    api: string;
                    dataContractJsDoc: string;
                    dataContracts: string;
                    enumDataContract: string;
                    httpClient: string;
                    interfaceDataContract: string;
                    objectFieldJsDoc: string;
                    routeName: string;
                    routeTypes: string;
                    typeDataContract: string;
                };
                toJS: boolean;
                typeNameResolverName: string;
                typePrefix: string;
                typeSuffix: string;
                unwrapResponseData: boolean;
                url: string;
                version: string;
            },
        >

      Returns Promise<
          {
              configuration: | GenerateApiConfiguration
              | {
                  apiConfig: {
                      basePath: any;
                      baseUrl: any;
                      externalDocs: any;
                      host: any;
                      info: any;
                      servers: any;
                      tags: unknown[];
                      title: any;
                      version: any;
                  };
                  config: CodeGenConfig;
                  customTranslator: null
                  | Translator;
                  extraTemplates: never[];
                  fileName: string;
                  generateResponses: boolean;
                  hasFormDataRoutes: boolean;
                  hasQueryRoutes: boolean;
                  hasSecurityRoutes: boolean;
                  modelTypes: any[];
                  routes: {
                      combined?: { moduleName: string; routes: ParsedRoute[] }[];
                      outOfModule: ParsedRoute[];
                  };
                  translateToJavaScript: boolean;
                  utils: {
                      _: LoDashStatic;
                      checkAndAddNull: (schema: any, type: any) => any;
                      classNameCase: (value: string) => Capitalize<string>;
                      fmtToJSDocLine: (
                          line: string,
                          __namedParameters: { eol?: boolean },
                      ) => string;
                      formatDescription: (description: any, inline: any) => any;
                      formatModelName: (
                          name: string,
                          options?: { type?: FormattingSchemaType },
                      ) => undefined | string;
                      formatters: {
                          enum: (parsedSchema: any) => any;
                          object: (parsedSchema: any) => any;
                          primitive: (parsedSchema: any) => any;
                      };
                      getComponentByRef: ($ref: string) => null | SchemaComponent;
                      getInlineParseContent: (
                          schema: string,
                          typeName: null | string,
                          schemaPath: string[],
                      ) => Record<string, any>;
                      getParseContent: (
                          schema: string,
                          typeName: null | string,
                          schemaPath: string[],
                      ) => Record<string, any>;
                      inlineExtraFormatters: {
                          enum: (parsedSchema: any) => any;
                          object: (parsedSchema: any) => any;
                      };
                      internalCase: (value: string) => string;
                      isNeedToAddNull: (schema: any, type: any) => any;
                      NameResolver: typeof NameResolver;
                      parseSchema: (
                          schema: string,
                          typeName?: null | string,
                          schemaPath?: string[],
                      ) => ParsedSchema<
                          | SchemaTypeObjectContent
                          | SchemaTypeEnumContent
                          | SchemaTypePrimitiveContent,
                      >;
                      pascalCase: (value: string) => Capitalize<string>;
                      require: (packageOrPath: string) => Promise<any>;
                      safeAddNullToType: (schema: any, type: any) => any;
                      Ts: {
                          ArrayType: (content: unknown) => string;
                          BooleanValue: (content: unknown) => string;
                          CodeGenKeyword: { UtilRequiredKeys: string };
                          EnumField: (key: unknown, value: unknown) => string;
                          EnumFieldsWrapper: (contents: Record<string, unknown>[]) => string;
                          EnumUsageKey: (enumStruct: unknown, key: unknown) => string;
                          ExpressionGroup: (content: unknown) => string;
                          InterfaceDynamicField: (key: unknown, value: unknown) => string;
                          IntersectionType: (contents: unknown[]) => string;
                          Keyword: {
                              Any: string;
                              Array: string;
                              Boolean: string;
                              Date: string;
                              Enum: string;
                              File: string;
                              Interface: string;
                              Intersection: string;
                              Null: string;
                              Number: string;
                              Object: string;
                              Record: string;
                              String: string;
                              Type: string;
                              Undefined: string;
                              Union: string;
                              Unknown: string;
                              Void: string;
                          };
                          MultilineComment: (
                              contents: unknown[],
                              formatFn: (arg: unknown) => unknown,
                          ) => string[];
                          NullValue: () => string;
                          NumberValue: (content: unknown) => string;
                          ObjectWrapper: (content: unknown) => string;
                          RecordType: (key: unknown, value: unknown) => string;
                          StringValue: (content: unknown) => string;
                          Tuple: (values: unknown[]) => string;
                          TypeField: (__namedParameters: Record<string, unknown>) => string;
                          TypeWithGeneric: (typeName: unknown, genericArgs: unknown[]) => string;
                          UnionType: (contents: unknown[]) => string;
                      };
                  };
              };
              createFile: (
                  __namedParameters: {
                      content: any;
                      fileName: any;
                      path: any;
                      withPrefix: any;
                  },
              ) => void;
              files: TranslatorIO[];
              formatTSContent: (
                  code: string,
                  __namedParameters?: { format?: boolean; removeUnusedImports?: boolean },
              ) => Promise<string>;
              getTemplate: (
                  name: string,
                  fileName: string,
                  path?: string,
              ) => undefined | string;
              renderTemplate: (
                  template: string,
                  configuration: object,
                  options?: object,
              ) => string;
          },
      >

    Settings

    Member Visibility