rawsql-ts 0.24.3 → 0.25.0

package/dist/src/index.d.ts

@@ -42,6 +42,8 @@ export * from './transformers/CTEDependencyAnalyzer';
 export * from './transformers/CTETableReferenceCollector';
 export * from './transformers/CTEQueryDecomposer';
 export type { CTERestorationResult } from './transformers/CTEQueryDecomposer';
+export * from './transformers/NamedQueryDefinitionExtractor';
+export * from './transformers/AstCommentAttachmentExtractor';
 export * from './transformers/CTEComposer';
 export * from './transformers/CTERenamer';
 export * from './transformers/AliasRenamer';
@@ -50,6 +52,7 @@ export * from './formatters/OriginalFormatRestorer';
 export * from './transformers/SqlIdentifierRenamer';
 export type { ScopeRange } from './transformers/SqlIdentifierRenamer';
 export * from './transformers/ColumnReferenceCollector';
+export * from './transformers/ClauseScopedColumnReferenceCollector';
 export * from './transformers/Formatter';
 export * from './transformers/SqlFormatter';
 export * from './transformers/QueryBuilder';
@@ -64,6 +67,9 @@ export * from './transformers/SimulatedSelectConverter';
 export * from './transformers/DDLToFixtureConverter';
 export * from './transformers/DDLGeneralizer';
 export * from './transformers/DDLDiffGenerator';
+export * from './transformers/SelectBodyExtractor';
+export * from './transformers/SelectOutputCollector';
+export * from './transformers/WildcardColumnInferenceCollector';
 export * from './transformers/SelectValueCollector';
 export * from './transformers/SelectableColumnCollector';
 export { DuplicateDetectionMode } from './transformers/SelectableColumnCollector';

package/dist/src/models/ValueComponent.d.ts

@@ -108,12 +108,13 @@ export declare class ParameterExpression extends SqlComponent {
     static kind: symbol;
     name: RawString;
     value: SqlParameterValue;
+    sourceText: string | null;
     /**
      * The index assigned by the formatter when generating parameterized queries.
      * Used for naming parameters like $1, $2, etc.
      */
     index: number | null;
-    constructor(name: string, value?: SqlParameterValue);
+    constructor(name: string, value?: SqlParameterValue, sourceText?: string | null);
 }
 export declare class SwitchCaseArgument extends SqlComponent {
     static kind: symbol;

package/dist/src/parsers/FunctionExpressionParser.d.ts

@@ -6,6 +6,7 @@ export declare class FunctionExpressionParser {
      */
     private static readonly AGGREGATE_FUNCTIONS_WITH_ORDER_BY;
     private static readonly SQL_JSON_CONSTRUCTORS;
+    private static readonly QUANTIFIED_COMPARISON_FUNCTIONS;
     /**
      * Parse ARRAY expressions - handles both ARRAY[...] (literal) and ARRAY(...) (query) syntax
      * @param lexemes Array of lexemes to parse
@@ -31,6 +32,8 @@ export declare class FunctionExpressionParser {
      */
     private static parseBetweenUpperBound;
     private static parseFunctionCall;
+    private static isSubqueryArgumentStart;
+    private static parseSubqueryArgumentWithComments;
     /**
      * Captures SQL/JSON constructor arguments as RawString while preserving closing
      * comments via getClosingComments. Empty argument lists still use ValueList.

package/dist/src/parsers/ParameterDecorator.d.ts

@@ -5,11 +5,11 @@
 export declare class ParameterDecorator {
     prefix: string;
     suffix: string;
-    style: 'named' | 'indexed' | 'anonymous';
+    style: 'named' | 'indexed' | 'anonymous' | 'original';
     constructor(options?: {
         prefix?: string;
         suffix?: string;
-        style?: 'named' | 'indexed' | 'anonymous';
+        style?: 'named' | 'indexed' | 'anonymous' | 'original';
     });
     /**
      * Decorate a parameter token with DBMS-specific format.

package/dist/src/parsers/SqlPrintTokenParser.d.ts

@@ -9,11 +9,14 @@ import { CreateTableQuery } from "../models/CreateTableQuery";
 export declare enum ParameterStyle {
     Anonymous = "anonymous",
     Indexed = "indexed",
-    Named = "named"
+    Named = "named",
+    Original = "original"
 }
 export type CastStyle = 'postgres' | 'standard';
 export type ConstraintStyle = 'postgres' | 'mysql';
-export type SourceAliasStyle = 'as' | 'implicit';
+export type AliasKeywordStyle = 'explicit' | 'omit' | 'as' | 'implicit';
+export type SourceAliasStyle = AliasKeywordStyle;
+export type ColumnAliasStyle = AliasKeywordStyle;
 export type OrderByDefaultDirectionStyle = 'omit' | 'explicit';
 export interface FormatterConfig {
     identifierEscape?: {
@@ -26,7 +29,7 @@ export interface FormatterConfig {
         end: string;
     };
     /**
-     * Parameter style: anonymous (?), indexed ($1), or named (:name)
+     * Parameter style: anonymous (?), indexed ($1), named (:name), or original parsed spelling.
      */
     parameterStyle?: ParameterStyle;
     /** Controls how CAST expressions are rendered */
@@ -35,6 +38,8 @@ export interface FormatterConfig {
     constraintStyle?: ConstraintStyle;
     /** Controls whether source aliases are rendered with an explicit AS keyword */
     sourceAliasStyle?: SourceAliasStyle;
+    /** Controls whether column aliases are rendered with an explicit AS keyword */
+    columnAliasStyle?: ColumnAliasStyle;
     /** Controls whether the default ASC direction is omitted or rendered explicitly */
     orderByDefaultDirectionStyle?: OrderByDefaultDirectionStyle;
 }
@@ -55,6 +60,7 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
     private castStyle;
     private constraintStyle;
     private sourceAliasStyle;
+    private columnAliasStyle;
     private orderByDefaultDirectionStyle;
     private readonly normalizeJoinConditionOrder;
     private readonly listContinuationCommentComponents;
@@ -70,10 +76,11 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
             start: string;
             end: string;
         };
-        parameterStyle?: 'anonymous' | 'indexed' | 'named';
+        parameterStyle?: 'anonymous' | 'indexed' | 'named' | 'original';
         castStyle?: CastStyle;
         constraintStyle?: ConstraintStyle;
         sourceAliasStyle?: SourceAliasStyle;
+        columnAliasStyle?: ColumnAliasStyle;
         orderByDefaultDirectionStyle?: OrderByDefaultDirectionStyle;
         joinConditionOrderByDeclaration?: boolean;
     });
@@ -204,6 +211,7 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
     private visitValueList;
     private visitColumnReference;
     private visitFunctionCall;
+    private isQuantifiedComparisonFunction;
     private relocateGroupingSetComments;
     private isGroupingSetsFunction;
     private extractPositionedComments;
@@ -219,6 +227,8 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
     private visitParenExpression;
     private visitCastExpression;
     private visitCaseExpression;
+    private removeCaseAfterCommentsDuplicatedOnFirstWhen;
+    private normalizeCommentSignature;
     private extractSwitchAfterComments;
     private collectCaseLeadingCommentsFromSwitch;
     private findCaseKeyToken;
@@ -260,6 +270,8 @@ export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrint
     private visitTableSource;
     private visitSourceExpression;
     private appendSourceAliasKeyword;
+    private shouldPrintColumnAliasKeyword;
+    private normalizeAliasKeywordStyle;
     visitFromClause(arg: FromClause): SqlPrintToken;
     visitJoinClause(arg: JoinClause): SqlPrintToken;
     visitJoinOnClause(arg: JoinOnClause): SqlPrintToken;

package/dist/src/transformers/AstCommentAttachmentExtractor.d.ts

@@ -0,0 +1,61 @@
+import { SqlComponent } from "../models/SqlComponent";
+/**
+ * Source span for a comment when parser metadata is available.
+ *
+ * @remarks The current parser stores comment text on AST nodes but does not
+ * retain reliable per-comment source spans, so extractors usually omit this.
+ */
+export interface AstCommentSourceRange {
+    start: number;
+    end: number;
+}
+/**
+ * Conservatively describes where an AST comment fact appears relative to syntax.
+ */
+export type AstCommentPlacement = "leading" | "trailing" | "inner" | "detached";
+/**
+ * Generic comment fact extracted from SQL AST comment metadata.
+ *
+ * @remarks `targetNode` is optional because SQL comments do not always have a
+ * strict syntactic owner. Ambiguous legacy buckets are emitted as detached.
+ */
+export interface AstCommentAttachment {
+    text: string;
+    sourceOrder: number;
+    placement: AstCommentPlacement;
+    targetNode?: SqlComponent;
+    range?: AstCommentSourceRange;
+}
+/**
+ * Extracts comment attachment facts already represented in the SQL AST.
+ *
+ * @remarks This API does not infer product-specific meanings or rewrite
+ * comments. It returns a deterministic flat list without mutating the input AST.
+ */
+export declare class AstCommentAttachmentExtractor {
+    private readonly attachments;
+    private readonly visited;
+    private readonly suppressedDetachedCommentArrays;
+    /**
+     * Extract comment attachment facts from a SQL AST component.
+     */
+    static extract(input: SqlComponent | null | undefined): AstCommentAttachment[];
+    private visit;
+    private visitSqlComponent;
+    private visitFallbackProperties;
+    private shouldSkipProperty;
+    private emitHeaderComments;
+    private emitLegacyComments;
+    private emitPositionedComments;
+    private emitSelectItemKeywordComments;
+    private emitKeywordPositionedComments;
+    private emitDetachedComments;
+    private emitComments;
+    private isSelectQuery;
+    private suppressWithClauseTrailingCommentsAlreadyCopiedToQuery;
+    private containsCommentSequence;
+}
+/**
+ * Extract comment attachment facts from a SQL AST component.
+ */
+export declare function extractAstCommentAttachments(input: SqlComponent | null | undefined): AstCommentAttachment[];

package/dist/src/transformers/ClauseScopedColumnReferenceCollector.d.ts

@@ -0,0 +1,47 @@
+import { SimpleSelectQuery } from "../models/SimpleSelectQuery";
+import { ColumnReference, ValueComponent } from "../models/ValueComponent";
+export type ClauseScopedColumnReferenceClause = "select" | "where" | "joinOn" | "groupBy" | "having" | "orderBy" | "window" | "limitOffset";
+export interface ClauseScopedColumnReferenceInfo {
+    clause: ClauseScopedColumnReferenceClause;
+    reference: ColumnReference;
+    qualifiedName: string;
+    namespaces: string[];
+    namespace: string | null;
+    column: string;
+    expression: ValueComponent;
+}
+export interface ClauseScopedColumnReferences {
+    select: ClauseScopedColumnReferenceInfo[];
+    where: ClauseScopedColumnReferenceInfo[];
+    joinOn: ClauseScopedColumnReferenceInfo[];
+    groupBy: ClauseScopedColumnReferenceInfo[];
+    having: ClauseScopedColumnReferenceInfo[];
+    orderBy: ClauseScopedColumnReferenceInfo[];
+    window: ClauseScopedColumnReferenceInfo[];
+    limitOffset: ClauseScopedColumnReferenceInfo[];
+}
+/**
+ * Collects ColumnReference nodes grouped by the root SimpleSelectQuery clause that owns them.
+ *
+ * Subquery and CTE bodies are intentionally not traversed because they have their own query-body
+ * ownership. Use ColumnReferenceCollector when comprehensive tree traversal is required.
+ */
+export declare class ClauseScopedColumnReferenceCollector {
+    collect(query: SimpleSelectQuery): ClauseScopedColumnReferences;
+    private createEmptyResult;
+    private collectFromSelectClause;
+    private collectFromJoinClauses;
+    private collectFromWhereClause;
+    private collectFromGroupByClause;
+    private collectFromHavingClause;
+    private collectFromOrderByClause;
+    private collectFromLimitClause;
+    private collectFromOffsetClause;
+    private collectFromFetchClause;
+    private collectFromWindowsClause;
+    private collectFromValueComponent;
+    private collectFromFunctionCall;
+    private collectFromWindowFrameExpression;
+    private createInfo;
+    private getNameText;
+}

package/dist/src/transformers/LinePrinter.d.ts

@@ -1,4 +1,4 @@
-export type NewlineLogicalName = 'lf' | 'crlf' | 'cr';
+export type NewlineLogicalName = 'lf' | 'crlf' | 'cr' | 'space';
 export type NewlineOption = NewlineLogicalName | '\n' | '\r\n' | '\r' | ' ';
 export type IndentCharLogicalName = 'space' | 'tab';
 export type IndentCharOption = IndentCharLogicalName | string;

package/dist/src/transformers/NamedQueryDefinitionExtractor.d.ts

@@ -0,0 +1,53 @@
+import { CTEQuery } from "../models/Clause";
+import { SqlComponent } from "../models/SqlComponent";
+/**
+ * Source span for a named query definition when parser position metadata is available.
+ *
+ * @remarks The current extractor does not synthesize ranges. `range` and `nameRange`
+ * are returned as `null` until AST nodes expose reliable definition spans.
+ */
+export interface NamedQueryDefinitionSourceRange {
+    start: number;
+    end: number;
+}
+/**
+ * DTO-style representation of a named query definition from a SQL AST.
+ */
+export interface NamedQueryDefinition {
+    /** The stable definition name, such as a CTE alias. */
+    name: string;
+    /** The AST query node that defines the named query. */
+    query: CTEQuery;
+    /** Whether the definition belongs to a `WITH RECURSIVE` clause, when that context is available. */
+    recursive?: boolean;
+    /** Full definition source range when available. Currently `null`. */
+    range: NamedQueryDefinitionSourceRange | null;
+    /** Definition-name source range when available. Currently `null`. */
+    nameRange: NamedQueryDefinitionSourceRange | null;
+}
+/**
+ * Extracts named query definitions, starting with CTE definitions from `WITH` clauses.
+ *
+ * @remarks Definitions are emitted in SQL source order. For nested CTEs, the outer
+ * CTE definition is emitted when its name is encountered, then definitions inside
+ * that CTE body are emitted before later sibling CTE definitions.
+ */
+export declare class NamedQueryDefinitionExtractor {
+    private readonly definitions;
+    private readonly visited;
+    /**
+     * Extract named query definitions from an AST component.
+     */
+    static extract(input: SqlComponent | null | undefined): NamedQueryDefinition[];
+    private visit;
+    private visitSelectQuery;
+    private visitSimpleSelectQuery;
+    private visitInsertQuery;
+    private visitUpdateQuery;
+    private visitDeleteQuery;
+    private visitMergeQuery;
+    private visitWithClause;
+    private visitCommonTable;
+    private visitKnownSqlComponent;
+    private visitKnownValueComponent;
+}

package/dist/src/transformers/OnelineFormattingHelper.d.ts

@@ -5,6 +5,7 @@ export interface OnelineFormattingOptions {
     parenthesesOneLine: boolean;
     betweenOneLine: boolean;
     valuesOneLine: boolean;
+    inOneLine: boolean;
     joinOneLine: boolean;
     caseOneLine: boolean;
     subqueryOneLine: boolean;

package/dist/src/transformers/SelectBodyExtractor.d.ts

@@ -0,0 +1,21 @@
+import { SelectQuery } from "../models/SelectQuery";
+import { SqlComponent } from "../models/SqlComponent";
+export type SelectBodyWrapperKind = "create-table-as" | "create-view" | "create-materialized-view" | "insert-select";
+export interface SelectBodyExtractionResult {
+    supported: boolean;
+    kind: SelectBodyWrapperKind | null;
+    targetName: string | null;
+    selectQuery: SelectQuery | null;
+    reason?: string;
+}
+export declare class SelectBodyExtractor {
+    static extract(input: string | SqlComponent): SelectBodyExtractionResult;
+    private static extractFromSql;
+    private static extractFromStatement;
+    private static extractCreateViewFromLexemes;
+    private static isCreateViewStatement;
+    private static consumeBalancedParentheses;
+    private static createTableTargetName;
+    private static insertTargetName;
+    private static unsupported;
+}

package/dist/src/transformers/SelectOutputCollector.d.ts

@@ -0,0 +1,47 @@
+import { CommonTable } from "../models/Clause";
+import { SqlComponent } from "../models/SqlComponent";
+import { ValueComponent } from "../models/ValueComponent";
+import { TableColumnResolver } from "./TableColumnResolver";
+export interface SelectOutputColumn {
+    name: string;
+    value: ValueComponent;
+    outputIndex: number;
+    sourceAlias: string | null;
+    sourceName: string | null;
+    sourceColumnName: string | null;
+}
+/**
+ * Collects SELECT output columns without collapsing duplicate output names.
+ *
+ * This collector is intended for callers that need stable SELECT-list positions.
+ * It keeps output order and assigns outputIndex after supported wildcard expansion.
+ */
+export declare class SelectOutputCollector {
+    private tableColumnResolver;
+    private commonTableCollector;
+    private commonTables;
+    constructor(tableColumnResolver?: TableColumnResolver | null, initialCommonTables?: CommonTable[] | null);
+    collect(arg: SqlComponent): SelectOutputColumn[];
+    private collectRaw;
+    private collectSimpleSelectQuery;
+    private collectSelectItem;
+    private expandWildcard;
+    private collectFromClause;
+    private collectJoinClause;
+    private getJoinSourceName;
+    private collectSourceExpression;
+    private findCommonTable;
+    private collectTableSource;
+    private collectNestedSelectQuery;
+    private collectCteQuery;
+    private collectReturningOutputs;
+    private extractReturningOutputs;
+    private extractSelectItemName;
+    private qualifyOutputs;
+    private createExplicitOutput;
+    private resolveColumnSourceMetadata;
+    private getSourceMatchNames;
+    private getColumnReferenceSourceAlias;
+    private getColumnReferenceSourceName;
+    private isSelectQuery;
+}

package/dist/src/transformers/SelectValueCollector.d.ts

@@ -16,7 +16,8 @@ export declare class SelectValueCollector implements SqlComponentVisitor<void> {
     private commonTableCollector;
     private commonTables;
     initialCommonTables: CommonTable[] | null;
-    constructor(tableColumnResolver?: TableColumnResolver | null, initialCommonTables?: CommonTable[] | null);
+    private preserveDuplicateSelectItems;
+    constructor(tableColumnResolver?: TableColumnResolver | null, initialCommonTables?: CommonTable[] | null, preserveDuplicateSelectItems?: boolean);
     /**
      * Get all collected SelectItems as an array of objects with name and value properties
      * @returns An array of objects with name (string) and value (ValueComponent) properties
@@ -50,11 +51,18 @@ export declare class SelectValueCollector implements SqlComponentVisitor<void> {
     private processFromClause;
     private processJoinClause;
     private processSourceExpression;
+    private expandWildcardValue;
+    private collectFromClauseValues;
+    private collectJoinClauseValues;
+    private getJoinSourceName;
+    private collectSourceExpressionValues;
     private visitSelectClause;
     private processSelectItem;
     private visitSourceExpression;
     private visitFromClause;
     private addSelectValueAsUnique;
+    private addSelectValue;
+    private addSelectValueFromSelectItem;
     private collectValuesFromCteQuery;
     private collectValuesFromReturning;
     private extractValuesFromReturningClause;

package/dist/src/transformers/SqlFormatter.d.ts

@@ -1,4 +1,4 @@
-import { CastStyle, ConstraintStyle, SourceAliasStyle, OrderByDefaultDirectionStyle } from '../parsers/SqlPrintTokenParser';
+import { CastStyle, ConstraintStyle, SourceAliasStyle, ColumnAliasStyle, OrderByDefaultDirectionStyle } from '../parsers/SqlPrintTokenParser';
 import { CommaBreakStyle, AndBreakStyle, OrBreakStyle, JoinOnBreakStyle } from './SqlPrinter';
 import { CommentExportMode } from '../types/Formatting';
 import { IndentCharOption, NewlineOption } from './LinePrinter';
@@ -38,7 +38,7 @@ export interface BaseFormattingOptions {
     /** Newline character style (logical 'lf'/'crlf'/'cr' or literal newline string) */
     newline?: NewlineOption;
     /** Case transformation for SQL keywords */
-    keywordCase?: 'none' | 'upper' | 'lower';
+    keywordCase?: 'none' | 'upper' | 'lower' | 'preserve';
     /** Style for comma line breaks */
     commaBreak?: CommaBreakStyle;
     /** Style for comma line breaks inside WITH clause definitions */
@@ -63,6 +63,8 @@ export interface BaseFormattingOptions {
     betweenOneLine?: boolean;
     /** Keep VALUES clause on one line regardless of comma break settings */
     valuesOneLine?: boolean;
+    /** Keep IN value lists on one line until oneLineMaxLength forces expansion */
+    inOneLine?: boolean;
     /** Keep JOIN conditions on one line regardless of AND/OR break settings */
     joinOneLine?: boolean;
     /** Keep CASE expressions on one line regardless of formatting settings */
@@ -75,8 +77,8 @@ export interface BaseFormattingOptions {
     insertColumnsOneLine?: boolean;
     /** Keep MERGE WHEN clause predicates on one line regardless of AND break settings */
     whenOneLine?: boolean;
-    /** Maximum rendered width for opt-in one-line constructs. Omit to keep legacy unlimited one-line behavior. */
-    oneLineMaxLength?: number;
+    /** Maximum rendered width for opt-in one-line constructs. Use 0, null, or omit to disable the limit. */
+    oneLineMaxLength?: number | null;
     /** Indent AND/OR continuation lines inside JOIN ON predicates */
     joinConditionContinuationIndent?: boolean;
     /** Reorder JOIN ON column comparisons to follow table declaration order */
@@ -106,13 +108,15 @@ export interface SqlFormatterOptions extends BaseFormattingOptions {
         end: string;
     };
     /** Style for parameter formatting */
-    parameterStyle?: 'anonymous' | 'indexed' | 'named';
+    parameterStyle?: 'anonymous' | 'indexed' | 'named' | 'original';
     /** Preferred CAST rendering style */
     castStyle?: CastStyle;
     /** Constraint rendering style (affects CREATE TABLE constraint layout) */
     constraintStyle?: ConstraintStyle;
     /** Source alias rendering style for FROM/JOIN sources */
     sourceAliasStyle?: SourceAliasStyle;
+    /** Column alias rendering style for SELECT items */
+    columnAliasStyle?: ColumnAliasStyle;
     /** Default ORDER BY direction rendering style */
     orderByDefaultDirectionStyle?: OrderByDefaultDirectionStyle;
 }

package/dist/src/transformers/SqlPrinter.d.ts

@@ -28,8 +28,9 @@ export type OrBreakStyle = 'none' | 'before' | 'after';
  * JoinOnBreakStyle determines whether JOIN ON starts on the JOIN line or its own indented line.
  * - 'none': Keep ON inline with the JOIN target
  * - 'before': Break before ON and indent the join condition
+ * - 'after': Legacy alias accepted as 'none'
  */
-export type JoinOnBreakStyle = 'none' | 'before';
+export type JoinOnBreakStyle = 'none' | 'before' | 'after';
 /**
  * Options for configuring SqlPrinter formatting behavior
  */
@@ -74,7 +75,7 @@ export declare class SqlPrinter {
     andBreak: AndBreakStyle;
     /** OR break style: 'none', 'before', or 'after' */
     orBreak: OrBreakStyle;
-    /** JOIN ON break style: 'none' or 'before' */
+    /** JOIN ON break style: 'none' or 'before' (legacy 'after' is treated as 'none') */
     joinOnBreak: JoinOnBreakStyle;
     /** Keyword case style: 'none', 'upper' | 'lower' */
     keywordCase: 'none' | 'upper' | 'lower';
@@ -94,6 +95,8 @@ export declare class SqlPrinter {
     private betweenOneLine;
     /** Whether to keep VALUES clause on one line */
     private valuesOneLine;
+    /** Whether to keep IN value lists on one line */
+    private inOneLine;
     /** Whether to keep JOIN conditions on one line */
     private joinOneLine;
     /** Whether to keep CASE expressions on one line */
@@ -145,6 +148,7 @@ export declare class SqlPrinter {
     private shouldAlignExplainStatementChild;
     private shouldExpandCommentedFunctionCall;
     private containsCommentBlock;
+    private containsRenderableCommentBlock;
     private isLogicalOperatorWithComment;
     private currentLineEndsWithLogicalOperator;
     private isCaseContext;
@@ -183,6 +187,8 @@ export declare class SqlPrinter {
      * Decides whether the current container should collapse into a single line.
      */
     private shouldFormatContainerAsOneline;
+    private isInValueListExpression;
+    private getInValueListParts;
     /**
      * Detects an INSERT column list that must stay on a single line.
      */
@@ -206,8 +212,11 @@ export declare class SqlPrinter {
     private normalizeSmartBlockLine;
     private extractLineCommentContent;
     private flushSmartCommentBlockBuilder;
+    private shouldFallbackSmartLineCommentToBlock;
+    private buildSmartLineComment;
     private collectCommentBlockLines;
     private extractRawCommentBlockLines;
+    private extractDirectBlockCommentTexts;
     private normalizeCommentForSmart;
     private buildBlockComment;
     private getIndentString;
@@ -236,12 +245,15 @@ export declare class SqlPrinter {
      */
     private isOnelineMode;
     private normalizeOneLineMaxLength;
+    private normalizeKeywordCase;
+    private normalizeJoinOnBreak;
     private fitsOneLineMaxLength;
     /**
      * Handles CTE tokens with one-liner formatting.
      * Creates a nested SqlPrinter instance for proper CTE oneline formatting.
      */
     private tryHandleCteOnelineToken;
+    private shouldPreserveCteComments;
     /**
      * Creates a SqlPrinter instance configured for CTE oneline formatting.
      */
@@ -251,6 +263,9 @@ export declare class SqlPrinter {
      * Creates a unified oneline printer that formats everything as one line regardless of content type.
      */
     private tryHandleOnelineToken;
+    private tryHandleInOneLineToken;
+    private appendExpandedInValueList;
+    private splitValueListItems;
     private isBooleanParenExpression;
     private containsLogicalOperator;
     private getClauseBreakIndentLevel;