@kubb/parser-ts 4.1.4 → 5.0.0-alpha.32

package/dist/factory-BJCGLhSr.d.ts

@@ -1,227 +0,0 @@
-import ts from "typescript";
-
-//#region src/factory.d.ts
-declare const modifiers: {
-  readonly async: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>;
-  readonly export: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>;
-  readonly const: ts.ModifierToken<ts.SyntaxKind.ConstKeyword>;
-  readonly static: ts.ModifierToken<ts.SyntaxKind.StaticKeyword>;
-};
-declare const syntaxKind: {
-  readonly union: 192;
-};
-declare function createQuestionToken(token?: boolean | ts.QuestionToken): ts.PunctuationToken<ts.SyntaxKind.QuestionToken> | undefined;
-declare function createIntersectionDeclaration({
-  nodes,
-  withParentheses
-}: {
-  nodes: Array<ts.TypeNode>;
-  withParentheses?: boolean;
-}): ts.TypeNode | null;
-/**
- * Minimum nodes length of 2
- * @example `string & number`
- */
-declare function createTupleDeclaration({
-  nodes,
-  withParentheses
-}: {
-  nodes: Array<ts.TypeNode>;
-  withParentheses?: boolean;
-}): ts.TypeNode | null;
-declare function createArrayDeclaration({
-  nodes
-}: {
-  nodes: Array<ts.TypeNode>;
-}): ts.TypeNode | null;
-/**
- * Minimum nodes length of 2
- * @example `string | number`
- */
-declare function createUnionDeclaration({
-  nodes,
-  withParentheses
-}: {
-  nodes: Array<ts.TypeNode>;
-  withParentheses?: boolean;
-}): ts.TypeNode;
-declare function createPropertySignature({
-  readOnly,
-  modifiers,
-  name,
-  questionToken,
-  type
-}: {
-  readOnly?: boolean;
-  modifiers?: Array<ts.Modifier>;
-  name: ts.PropertyName | string;
-  questionToken?: ts.QuestionToken | boolean;
-  type?: ts.TypeNode;
-}): ts.PropertySignature;
-declare function createParameterSignature(name: string | ts.BindingName, {
-  modifiers,
-  dotDotDotToken,
-  questionToken,
-  type,
-  initializer
-}: {
-  decorators?: Array<ts.Decorator>;
-  modifiers?: Array<ts.Modifier>;
-  dotDotDotToken?: ts.DotDotDotToken;
-  questionToken?: ts.QuestionToken | boolean;
-  type?: ts.TypeNode;
-  initializer?: ts.Expression;
-}): ts.ParameterDeclaration;
-declare function createJSDoc({
-  comments
-}: {
-  comments: string[];
-}): ts.JSDoc | null;
-/**
- * @link https://github.com/microsoft/TypeScript/issues/44151
- */
-declare function appendJSDocToNode<TNode extends ts.Node>({
-  node,
-  comments
-}: {
-  node: TNode;
-  comments: Array<string | undefined>;
-}): TNode;
-declare function createIndexSignature(type: ts.TypeNode, {
-  modifiers,
-  indexName,
-  indexType
-}?: {
-  indexName?: string;
-  indexType?: ts.TypeNode;
-  decorators?: Array<ts.Decorator>;
-  modifiers?: Array<ts.Modifier>;
-}): ts.IndexSignatureDeclaration;
-declare function createTypeAliasDeclaration({
-  modifiers,
-  name,
-  typeParameters,
-  type
-}: {
-  modifiers?: Array<ts.Modifier>;
-  name: string | ts.Identifier;
-  typeParameters?: Array<ts.TypeParameterDeclaration>;
-  type: ts.TypeNode;
-}): ts.TypeAliasDeclaration;
-declare function createInterfaceDeclaration({
-  modifiers,
-  name,
-  typeParameters,
-  members
-}: {
-  modifiers?: Array<ts.Modifier>;
-  name: string | ts.Identifier;
-  typeParameters?: Array<ts.TypeParameterDeclaration>;
-  members: Array<ts.TypeElement>;
-}): ts.InterfaceDeclaration;
-declare function createTypeDeclaration({
-  syntax,
-  isExportable,
-  comments,
-  name,
-  type
-}: {
-  syntax: 'type' | 'interface';
-  comments: Array<string | undefined>;
-  isExportable?: boolean;
-  name: string | ts.Identifier;
-  type: ts.TypeNode;
-}): ts.TypeAliasDeclaration | ts.InterfaceDeclaration;
-declare function createNamespaceDeclaration({
-  statements,
-  name
-}: {
-  name: string;
-  statements: ts.Statement[];
-}): ts.ModuleDeclaration;
-/**
- * In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.
- * @example `import { Pet as Cat } from './Pet'`
- */
-declare function createImportDeclaration({
-  name,
-  path,
-  isTypeOnly,
-  isNameSpace
-}: {
-  name: string | Array<string | {
-    propertyName: string;
-    name?: string;
-  }>;
-  path: string;
-  isTypeOnly?: boolean;
-  isNameSpace?: boolean;
-}): ts.ImportDeclaration;
-declare function createExportDeclaration({
-  path,
-  asAlias,
-  isTypeOnly,
-  name
-}: {
-  path: string;
-  asAlias?: boolean;
-  isTypeOnly?: boolean;
-  name?: string | Array<ts.Identifier | string>;
-}): ts.ExportDeclaration;
-declare function createEnumDeclaration({
-  type,
-  name,
-  typeName,
-  enums
-}: {
-  /**
-   * @default `'enum'`
-   */
-  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
-  /**
-   * Enum name in camelCase.
-   */
-  name: string;
-  /**
-   * Enum name in PascalCase.
-   */
-  typeName: string;
-  enums: [key: string | number, value: string | number | boolean][];
-}): [name: ts.Node | undefined, type: ts.Node];
-declare function createOmitDeclaration({
-  keys,
-  type,
-  nonNullable
-}: {
-  keys: Array<string> | string;
-  type: ts.TypeNode;
-  nonNullable?: boolean;
-}): ts.TypeReferenceNode;
-declare const keywordTypeNodes: {
-  readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
-  readonly unknown: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
-  readonly void: ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword>;
-  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;
-};
-declare const createTypeLiteralNode: (members: readonly ts.TypeElement[] | undefined) => ts.TypeLiteralNode;
-declare const createTypeReferenceNode: (typeName: string | ts.EntityName, typeArguments?: readonly ts.TypeNode[]) => ts.TypeReferenceNode;
-declare const createNumericLiteral: (value: string | number, numericLiteralFlags?: ts.TokenFlags) => ts.NumericLiteral;
-declare const createStringLiteral: (text: string, isSingleQuote?: boolean) => ts.StringLiteral;
-declare const createArrayTypeNode: (elementType: ts.TypeNode) => ts.ArrayTypeNode;
-declare const createLiteralTypeNode: (literal: ts.LiteralTypeNode["literal"]) => ts.LiteralTypeNode;
-declare const createNull: () => ts.NullLiteral;
-declare const createIdentifier: (text: string) => ts.Identifier;
-declare const createOptionalTypeNode: (type: ts.TypeNode) => ts.OptionalTypeNode;
-declare const createTupleTypeNode: (elements: readonly (ts.TypeNode | ts.NamedTupleMember)[]) => ts.TupleTypeNode;
-declare const createRestTypeNode: (type: ts.TypeNode) => ts.RestTypeNode;
-declare const createTrue: () => ts.TrueLiteral;
-declare const createFalse: () => ts.FalseLiteral;
-//#endregion
-export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, factory_d_exports, keywordTypeNodes, modifiers, syntaxKind };
-//# sourceMappingURL=factory-BJCGLhSr.d.ts.map