js-to-sh/dist/types/index.d.ts

Turn javascript code into shellscript

// Generated by dts-bundle-generator v9.5.1

/**
 * Usado para validar se existe um certo tipo de comando existe no sistema operacional onde o script está rodando
 *
 * @async
 * @param {string} command
 * @returns {Promise<boolean>}
 */
declare const isCommand$1: (command: string) => Promise<boolean>
/**
 * Verifica se o path é um diretório
 *
 * @async
 * @param {string} path
 * @returns {Promise<boolean>}
 */
declare const isDir$1: (path: string) => Promise<boolean>
/**
 * Valida se o input de algo é vazio
 *
 * @param {any} content
 * @returns {boolean}
 */
declare const isEmpty$1: (content: any) => boolean
/**
 * Valida se o arquivo tem permissão de execução.
 *
 * @async
 * @param {string} filePath
 * @returns {Promise<boolean>}
 */
declare const isExecutable$1: (filePath: string) => Promise<boolean>
/**
 * Valida se o path é um arquivo
 *
 * @async
 * @param {string} filePath
 * @returns {unknown}
 */
declare const isFile$1: (filePath: string) => Promise<boolean>
/**
 * Valida se o input é um numero.
 *
 * @param {*} num
 * @returns {boolean}
 */
declare const isNumber$1: (num: any) => boolean
/**
 * Valida se há permissão de leitura.
 *
 * @async
 * @param {string} path
 * @returns {Promise<boolean>}
 */
declare const isReadable$1: (path: string) => Promise<boolean>
/**
 * Valida se há permissão de escrita.
 *
 * @async
 * @param {string} path
 * @returns {Promise<boolean>}
 */
declare const isWritable$1: (path: string) => Promise<boolean>
declare global {
	var isDir: typeof isDir$1
	var isEmpty: typeof isEmpty$1
	var isExecutable: typeof isExecutable$1
	var isFile: typeof isFile$1
	var isNumber: typeof isNumber$1
	var isReadable: typeof isReadable$1
	var isWritable: typeof isWritable$1
	var isCommand: typeof isCommand$1
	interface globalThis {
		isDir: typeof isDir$1;
		isEmpty: typeof isEmpty$1;
		isExecutable: typeof isExecutable$1;
		isFile: typeof isFile$1;
		isNumber: typeof isNumber$1;
		isReadable: typeof isReadable$1;
		isWritable: typeof isWritable$1;
		isCommand: typeof isCommand$1;
		fetch: typeof fetchNew;
	}
}
export declare class Method<T extends MethodTypes, D = undefined> {
  interaction: MethodProps<T, D>
  static all: Map<'ElseStatement' | 'IfStatement' | 'BlockStatement' | 'BreakStatement' | 'ContinueStatement' | 'DebuggerStatement' | 'ClassDeclaration' | 'ClassExpression' | 'ExportDefaultDeclaration' | 'ExportAllDeclaration' | 'ExportNamedDeclaration' | 'FunctionDeclaration' | 'EmptyStatement' | 'ExpressionStatement' | 'DoWhileStatement' | 'ForInStatement' | 'ForOfStatement' | 'ForStatement' | 'WhileStatement' | 'ImportDeclaration' | 'LabeledStatement' | 'ReturnStatement' | 'SwitchStatement' | 'ThrowStatement' | 'TryStatement' | 'VariableDeclaration' | 'WithStatement' | 'ArrowFunctionExpression' | 'AssignmentExpression' | 'BinaryExpression' | 'ConditionalExpression' | 'MetaProperty' | 'ChainExpression' | 'JSXClosingElement' | 'JSXClosingFragment' | 'JSXExpressionContainer' | 'JSXOpeningElement' | 'JSXOpeningFragment' | 'JSXSpreadChild' | 'LogicalExpression' | 'NewExpression' | 'RestElement' | 'SequenceExpression' | 'SpreadElement' | 'AwaitExpression' | 'CallExpression' | 'ImportExpression' | 'FunctionExpression' | 'Literal' | 'TemplateLiteral' | 'MemberExpression' | 'ArrayExpression' | 'ArrayPattern' | 'Identifier' | 'Import' | 'JSXElement' | 'JSXFragment' | 'ObjectExpression' | 'ObjectPattern' | 'Super' | 'ThisExpression' | 'TaggedTemplateExpression' | 'UnaryExpression' | 'UpdateExpression' | 'YieldExpression' | 'PrivateIdentifier' | 'AssignmentPattern' | 'MethodDefinition' | 'Property', Method<'ElseStatement' | 'IfStatement' | 'BlockStatement' | 'BreakStatement' | 'ContinueStatement' | 'DebuggerStatement' | 'ClassDeclaration' | 'ClassExpression' | 'ExportDefaultDeclaration' | 'ExportAllDeclaration' | 'ExportNamedDeclaration' | 'FunctionDeclaration' | 'EmptyStatement' | 'ExpressionStatement' | 'DoWhileStatement' | 'ForInStatement' | 'ForOfStatement' | 'ForStatement' | 'WhileStatement' | 'ImportDeclaration' | 'LabeledStatement' | 'ReturnStatement' | 'SwitchStatement' | 'ThrowStatement' | 'TryStatement' | 'VariableDeclaration' | 'WithStatement' | 'ArrowFunctionExpression' | 'AssignmentExpression' | 'BinaryExpression' | 'ConditionalExpression' | 'MetaProperty' | 'ChainExpression' | 'JSXClosingElement' | 'JSXClosingFragment' | 'JSXExpressionContainer' | 'JSXOpeningElement' | 'JSXOpeningFragment' | 'JSXSpreadChild' | 'LogicalExpression' | 'NewExpression' | 'RestElement' | 'SequenceExpression' | 'SpreadElement' | 'AwaitExpression' | 'CallExpression' | 'ImportExpression' | 'FunctionExpression' | 'Literal' | 'TemplateLiteral' | 'MemberExpression' | 'ArrayExpression' | 'ArrayPattern' | 'Identifier' | 'Import' | 'JSXElement' | 'JSXFragment' | 'ObjectExpression' | 'ObjectPattern' | 'Super' | 'ThisExpression' | 'TaggedTemplateExpression' | 'UnaryExpression' | 'UpdateExpression' | 'YieldExpression' | 'PrivateIdentifier' | 'AssignmentPattern' | 'MethodDefinition' | 'Property', unknown>>
  static get<T extends ExistsMethods>(methodType: T): Method<T> | undefined;
  constructor(interaction: MethodProps<T, D>);
  subprocess<T extends MethodTypes, D = undefined>(methodType: T, node: ASTMap[T], data: D): string | string[];
}
export declare class Transpiler {
  static tabs: number
  static options: TransformOptions
  static globalDeclarations: Record<string, string>
  ast: Program
  constructor(options: TransformOptions);
  /**
	 * Carrega o AST do javascript, gera um json com todas as informações necessarias para a conversão para shell script
	 *
	 * @param {string | undefined} code
	 * @returns {Promise<(Program)>}
	 */
  static loader(code?: string): Program;
  parser(ast?: (Program)): string;
  /**
	 * Retorna o operador equivalente do javascript para o shell script
	 *
	 * @param {string} value
	 * @returns {string}
	 */
  static parseOperator(value: string): string;
  /**
	 * Formata retornos de strings para diversos tipo de uso (if, echo)
	 *
	 * @param {Expression['type']} type
	 * @param {(string | string[])} content
	 * @returns {string}
	 */
  static parseReturnString(type: Expression['type'] | PrivateIdentifier['type'], content: string | string[]): string;
}
export declare const fetchNew: (input: string | URL | globalThis.Request, init?: Omit<RequestInit, 'credentials'>) => Promise<Response>
/**
 * Quebra um array em linhas
 * Caso a linha esteja vazia, pule!
 * Caso seja o ultimo elemento da array, não quebre a linha.
 *
 * @export
 * @param {string[]} array
 * @returns {string}
 */
export declare function breakLines(array: (string | number)[]): string;
/**
 * Retorna o indent para melhor formatação no shell script
 *
 * @export
 * @param {number} tabs
 * @returns {string}
 */
export declare function getTabs(tabs: number): string;
export interface AccessorProperty extends _Node {
	type: 'AccessorProperty';
	key: PrivateIdentifier | Expression;
	value: any;
	decorators?: Decorator[];
	computed: boolean;
	static: boolean;
}
export interface ArrayExpression extends _Node {
	type: 'ArrayExpression';
	elements: (Expression | SpreadElement | null)[];
}
export interface ArrayPattern extends _Node {
	type: 'ArrayPattern';
	elements: Expression[];
}
export interface ArrowFunctionExpression extends _Node {
	type: 'ArrowFunctionExpression';
	params: Parameter[];
	body: Expression | BlockStatement;
	async: boolean;
	expression: boolean;
}
export interface AssignmentExpression extends _Node {
	type: 'AssignmentExpression';
	operator: string;
	left: Expression;
	right: Expression;
}
export interface AssignmentPattern extends _Node {
	type: 'AssignmentPattern';
	left: BindingPattern | Identifier;
	right?: Expression;
}
export interface AwaitExpression extends _Node {
	type: 'AwaitExpression';
	argument: Expression;
}
export interface BinaryExpression extends _Node {
	type: 'BinaryExpression';
	operator: string;
	left: Expression | PrivateIdentifier;
	right: Expression;
}
export interface BlockStatement extends BlockStatementBase {
	type: 'BlockStatement';
}
export interface BlockStatementBase extends _Node {
	body: Statement[];
}
export interface BreakStatement extends _Node {
	type: 'BreakStatement';
	label: Identifier | null;
}
export interface CallExpression extends _Node {
	type: 'CallExpression';
	callee: any;
	arguments: (Expression | SpreadElement)[];
	optional?: boolean;
}
export interface CatchClause extends _Node {
	type: 'CatchClause';
	param: BindingPattern | Identifier | null;
	body: BlockStatement;
}
export interface ChainExpression extends _Node {
	type: 'ChainExpression';
	expression: CallExpression | MemberExpression;
}
export interface ClassBody extends _Node {
	type: 'ClassBody';
	body: (ClassElement | PropertyDefinition$1 | AccessorProperty | StaticBlock)[];
}
export interface ClassDeclaration extends ClassDeclarationBase {
	type: 'ClassDeclaration';
}
export interface ClassDeclarationBase extends _Node {
	id: Identifier | null;
	body: ClassBody;
	superClass: Expression | null;
	decorators?: Decorator[];
}
export interface ClassExpression extends ClassDeclarationBase {
	type: 'ClassExpression';
}
export interface ConditionalExpression extends _Node {
	type: 'ConditionalExpression';
	test: Expression;
	consequent: Expression;
	alternate: Expression;
}
export interface ContinueStatement extends _Node {
	type: 'ContinueStatement';
	label: Identifier | null;
}
export interface DebuggerStatement extends _Node {
	type: 'DebuggerStatement';
}
export interface Decorator extends _Node {
	type: 'Decorator';
	expression: LeftHandSideExpression;
}
export interface DoWhileStatement extends _Node {
	type: 'DoWhileStatement';
	test: Expression;
	body: Statement;
}
export interface EmptyStatement extends _Node {
	type: 'EmptyStatement';
}
export interface ExportAllDeclaration extends _Node {
	type: 'ExportAllDeclaration';
	source: Literal;
	exported: Identifier | Literal | null;
	attributes?: ImportAttribute[];
}
export interface ExportDefaultDeclaration extends _Node {
	type: 'ExportDefaultDeclaration';
	declaration: ExportDeclaration | Expression;
}
export interface ExportNamedDeclaration extends _Node {
	type: 'ExportNamedDeclaration';
	declaration: ExportDeclaration | null;
	specifiers: ExportSpecifier[];
	source: Literal | null;
	attributes?: ImportAttribute[];
}
export interface ExportSpecifier extends _Node {
	type: 'ExportSpecifier';
	local: Identifier | Literal;
	exported: Identifier | Literal;
}
export interface ExpressionStatement extends _Node {
	type: 'ExpressionStatement';
	expression: Expression;
}
export interface ForInStatement extends _Node {
	type: 'ForInStatement';
	left: ForInitialiser;
	right: Expression;
	body: Statement;
}
export interface ForOfStatement extends _Node {
	type: 'ForOfStatement';
	left: ForInitialiser;
	right: Expression;
	body: Statement;
	await: boolean;
}
export interface ForStatement extends _Node {
	type: 'ForStatement';
	init: Expression | ForInitialiser | null;
	test: Expression | null;
	update: Expression | null;
	body: Statement;
}
export interface FunctionDeclaration extends FunctionDeclarationBase {
	type: 'FunctionDeclaration';
}
export interface FunctionDeclarationBase extends _Node {
	id: Identifier | null;
	generator: boolean;
	async: boolean;
	params: Parameter[];
	body?: BlockStatement | null;
}
export interface FunctionExpression extends FunctionDeclarationBase {
	type: 'FunctionExpression';
}
export interface Identifier extends _Node {
	type: 'Identifier';
	name: string;
}
export interface IfStatement extends _Node {
	type: 'IfStatement';
	test: Expression;
	consequent: Statement;
	alternate: Statement | null;
}
export interface Import extends _Node {
	type: 'Import';
}
export interface ImportAttribute extends _Node {
	type: 'ImportAttribute';
	key: Identifier | Literal;
	value: Literal;
}
export interface ImportDeclaration extends _Node {
	type: 'ImportDeclaration';
	source: Literal;
	specifiers: ImportClause[];
	attributes?: ImportAttribute[];
}
export interface ImportDefaultSpecifier extends _Node {
	type: 'ImportDefaultSpecifier';
	local: Identifier;
}
export interface ImportExpression extends _Node {
	type: 'ImportExpression';
	source: Expression;
	options?: Expression | null;
}
export interface ImportNamespaceSpecifier extends _Node {
	type: 'ImportNamespaceSpecifier';
	local: Identifier;
}
export interface ImportSpecifier extends _Node {
	type: 'ImportSpecifier';
	local: Identifier;
	imported: Identifier | Literal;
}
export interface JSXAttribute extends _Node {
	type: 'JSXAttribute';
	name: JSXNamespacedName | JSXIdentifier;
	value: JSXAttributeValue;
}
export interface JSXClosingElement extends _Node {
	type: 'JSXClosingElement';
	name: JSXTagNameExpression;
}
export interface JSXClosingFragment extends _Node {
	type: 'JSXClosingFragment';
}
export interface JSXElement extends _Node {
	type: 'JSXElement';
	openingElement: JSXOpeningElement;
	closingElement: JSXClosingElement | null;
	children: JSXChild[];
}
export interface JSXEmptyExpression extends _Node {
	type: 'JSXEmptyExpression';
}
export interface JSXExpressionContainer extends _Node {
	type: 'JSXExpressionContainer';
	expression: Expression | JSXEmptyExpression;
}
export interface JSXFragment extends _Node {
	type: 'JSXFragment';
	openingFragment: JSXOpeningFragment;
	closingFragment: JSXClosingFragment;
	children: JSXChild[];
}
export interface JSXIdentifier extends _Node {
	type: 'JSXIdentifier';
	name: string;
}
export interface JSXMemberExpression extends _Node {
	type: 'JSXMemberExpression';
	object: JSXTagNameExpression;
	property: JSXIdentifier;
}
export interface JSXNamespacedName extends _Node {
	type: 'JSXNamespacedName';
	namespace: JSXIdentifier | JSXMemberExpression;
	name: JSXIdentifier;
}
export interface JSXOpeningElement extends _Node {
	type: 'JSXOpeningElement';
	selfClosing: boolean;
	name: JSXTagNameExpression;
	attributes: (JSXAttribute | JSXSpreadAttribute)[];
}
export interface JSXOpeningFragment extends _Node {
	type: 'JSXOpeningFragment';
}
export interface JSXSpreadAttribute extends _Node {
	type: 'JSXSpreadAttribute';
	argument: Expression;
}
export interface JSXSpreadChild extends _Node {
	type: 'JSXSpreadChild';
	expression: Expression | JSXEmptyExpression;
}
export interface JSXText extends _Node {
	type: 'JSXText';
	value: string;
	raw?: string;
}
export interface LabeledStatement extends _Node {
	type: 'LabeledStatement';
	label: Identifier;
	body: Statement;
}
export interface Literal extends _Node {
	type: 'Literal';
	value: boolean | number | string | null | RegExp | bigint;
	raw?: string;
}
export interface LogicalExpression extends _Node {
	type: 'LogicalExpression';
	operator: string;
	left: Expression;
	right: Expression;
}
export interface MemberExpression extends _Node {
	type: 'MemberExpression';
	object: Expression | Super;
	property: Expression | PrivateIdentifier;
	computed?: boolean;
	optional?: boolean;
}
export interface MetaProperty extends _Node {
	type: 'MetaProperty';
	meta: Identifier;
	property: Identifier;
}
export interface MethodDefinition extends MethodDefinitionBase {
	type: 'MethodDefinition';
}
export interface MethodDefinitionBase extends _Node {
	key: Expression | PrivateIdentifier | null;
	value: FunctionExpression;
	computed: boolean;
	static: boolean;
	kind: 'method' | 'get' | 'set' | 'constructor';
	decorators?: Decorator[];
}
export interface NewExpression extends _Node {
	type: 'NewExpression';
	callee: LeftHandSideExpression;
	arguments: Expression[];
}
export interface ObjectExpression extends _Node {
	type: 'ObjectExpression';
	properties: ObjectLiteralElementLike[];
}
export interface ObjectPattern extends _Node {
	type: 'ObjectPattern';
	properties: ObjectLiteralElementLike[];
}
export interface Position {
	line: number;
	column: number;
}
export interface PrivateIdentifier extends _Node {
	type: 'PrivateIdentifier';
	name: string;
}
export interface Program extends _Node {
	type: 'Program';
	body: Statement[];
	sourceType: 'module' | 'script';
}
export interface Property extends _Node {
	type: 'Property';
	key: Expression;
	value: Expression | AssignmentPattern | BindingPattern | Identifier;
	computed: boolean;
	method: boolean;
	shorthand: boolean;
	kind: 'init' | 'get' | 'set';
}
export interface RestElement extends _Node {
	type: 'RestElement';
	argument: BindingPattern | Identifier | Expression | PropertyName;
	value?: AssignmentPattern;
}
export interface ReturnStatement extends _Node {
	type: 'ReturnStatement';
	argument: Expression | null;
}
export interface SequenceExpression extends _Node {
	type: 'SequenceExpression';
	expressions: Expression[];
}
export interface SourceLocation {
	source?: string | null;
	start: Position;
	end: Position;
}
export interface SpreadElement extends _Node {
	type: 'SpreadElement';
	argument: SpreadArgument;
}
export interface StaticBlock extends BlockStatementBase {
	type: 'StaticBlock';
}
export interface Super extends _Node {
	type: 'Super';
}
export interface SwitchCase extends _Node {
	type: 'SwitchCase';
	test: Expression | null;
	consequent: Statement[];
}
export interface SwitchStatement extends _Node {
	type: 'SwitchStatement';
	discriminant: Expression;
	cases: SwitchCase[];
}
export interface TaggedTemplateExpression extends _Node {
	type: 'TaggedTemplateExpression';
	tag: Expression;
	quasi: TemplateLiteral;
}
export interface TemplateElement extends _Node {
	type: 'TemplateElement';
	value: {
		raw: string;
		cooked: string | null;
	};
	tail: boolean;
}
export interface TemplateLiteral extends _Node {
	type: 'TemplateLiteral';
	quasis: TemplateElement[];
	expressions: Expression[];
}
export interface ThisExpression extends _Node {
	type: 'ThisExpression';
}
export interface ThrowStatement extends _Node {
	type: 'ThrowStatement';
	argument: Expression;
}
export interface TransformOptions {
	path: string;
	cwd?: string;
	debug?: boolean;
}
export interface TryStatement extends _Node {
	type: 'TryStatement';
	block: BlockStatement;
	handler: CatchClause | null;
	finalizer: BlockStatement | null;
}
export interface UnaryExpression extends _Node {
	type: 'UnaryExpression';
	operator: UnaryOperator;
	prefix: true;
	argument: Expression;
}
export interface UpdateExpression extends _Node {
	type: 'UpdateExpression';
	operator: UpdateOperator;
	argument: Expression;
	prefix: boolean;
}
export interface VariableDeclaration extends _Node {
	type: 'VariableDeclaration';
	declarations: VariableDeclarator[];
	kind: 'let' | 'const' | 'var';
}
export interface VariableDeclarator extends _Node {
	type: 'VariableDeclarator';
	id: Expression | BindingPattern | Identifier;
	init: Expression | null;
	definite?: boolean;
}
export interface WhileStatement extends _Node {
	type: 'WhileStatement';
	test: Expression;
	body: Statement;
}
export interface WithStatement extends _Node {
	type: 'WithStatement';
	object: Expression;
	body: Statement;
}
export interface YieldExpression extends _Node {
	type: 'YieldExpression';
	delegate: boolean;
	argument?: Expression | null;
}
export interface _Node {
	start?: number;
	end?: number;
	range?: [
		number,
		number
	];
	loc?: SourceLocation | null;
}
export type ASTMap = {
	[NodeType in ASTNode as NodeType['type']]: NodeType;
};
export type ASTNode = Statement | Expression | PrivateIdentifier | Parameter | ElseStatement | ObjectLiteralElementLike;
export type BindingPattern = ArrayPattern | ObjectPattern | Identifier;
export type ClassElement = FunctionExpression | MethodDefinition;
export type DeclarationStatement = ClassDeclaration | ClassExpression | ExportDefaultDeclaration | ExportAllDeclaration | ExportNamedDeclaration | FunctionDeclaration;
export type ElseStatement = ({
	type: 'ElseStatement';
}) & Omit<IfStatement, 'type'>;
export type ExistsMethods = ASTMap['Property' | 'ArrayExpression' | 'ArrowFunctionExpression' | 'AwaitExpression' | 'BinaryExpression' | 'CallExpression' | 'ClassDeclaration' | 'FunctionExpression' | 'Identifier' | 'Literal' | 'MemberExpression' | 'MetaProperty' | 'NewExpression' | 'ObjectExpression' | 'PrivateIdentifier' | 'TemplateLiteral' | 'BlockStatement' | 'BreakStatement' | 'ElseStatement' | 'ExpressionStatement' | 'ForOfStatement' | 'FunctionDeclaration' | 'IfStatement' | 'ImportDeclaration' | 'ReturnStatement' | 'SwitchStatement' | 'VariableDeclaration']['type'];
export type ExportDeclaration = ClassDeclaration | ClassExpression | FunctionDeclaration | VariableDeclaration;
export type Expression = ArrowFunctionExpression | AssignmentExpression | BinaryExpression | ConditionalExpression | MetaProperty | ChainExpression | JSXClosingElement | JSXClosingFragment | JSXExpressionContainer | JSXOpeningElement | JSXOpeningFragment | JSXSpreadChild | LogicalExpression | NewExpression | RestElement | SequenceExpression | SpreadElement | AwaitExpression | LeftHandSideExpression | UnaryExpression | UpdateExpression | YieldExpression;
export type ForInitialiser = Expression | VariableDeclaration;
export type ImportClause = ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier;
export type IterationStatement = DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | WhileStatement;
export type JSXAttributeValue = JSXIdentifier | Literal | JSXElement | JSXFragment | JSXExpressionContainer | JSXSpreadChild | null;
export type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText;
export type JSXExpression = JSXEmptyExpression | JSXSpreadChild | JSXExpressionContainer;
export type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
export type LeftHandSideExpression = CallExpression | ChainExpression | ImportExpression | ClassExpression | ClassDeclaration | FunctionExpression | LiteralExpression | MemberExpression | PrimaryExpression | TaggedTemplateExpression;
export type LiteralExpression = Literal | TemplateLiteral;
export type MethodProps<T extends MethodTypes, D = undefined> = {
	type: T;
	data?: D;
	parser: (node: ASTMap[T], options: MethodProps<T, D> & {
		subprocess<T extends MethodTypes, D>(methodType: T, node: ASTMap[T], data?: D): string | string[];
	}) => string | string[];
};
export type MethodTypes = keyof ASTMap;
export type ObjectLiteralElementLike = MethodDefinition | Property | RestElement | SpreadElement;
export type Parameter = AssignmentPattern | RestElement | ArrayPattern | ObjectPattern | Identifier;
export type PrimaryExpression = ArrayExpression | ArrayPattern | ClassExpression | FunctionExpression | Identifier | Import | JSXElement | JSXFragment | JSXOpeningElement | Literal | LiteralExpression | MetaProperty | ObjectExpression | ObjectPattern | Super | TemplateLiteral | ThisExpression;
export type PropertyName = Identifier | Literal;
export type RequestType = Omit<RequestInit, 'credentials'>;
export type SpreadArgument = BindingPattern | Identifier | Expression | PropertyName | SpreadElement;
export type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DeclarationStatement | EmptyStatement | ExpressionStatement | IfStatement | IterationStatement | ImportDeclaration | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WithStatement;
export type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
export type UpdateOperator = '++' | '--';
interface PropertyDefinition$1 extends _Node {
	type: 'PropertyDefinition';
	key: PrivateIdentifier | Expression;
	value: any;
	decorators?: Decorator[];
	computed: boolean;
	static: boolean;
}

export {
  isCommand$1 as isCommand,
  isDir$1 as isDir,
  isEmpty$1 as isEmpty,
  isExecutable$1 as isExecutable,
  isFile$1 as isFile,
  isNumber$1 as isNumber,
  isReadable$1 as isReadable,
  isWritable$1 as isWritable,
}

export {}