# Export Excel
URL: https://pro.rv-grid.com/api/export-excel/
Source: src/content/docs/api/export-excel.md
## Module Extensions

### `ColumnRegular` (Extended from `@revolist/revogrid`)

```ts
interface ColumnRegular {
  /**
       * Excel export-only properties and formatting. This does not affect the
       * rendered grid cell renderer.
       */
      excelExport?: ExcelExportColumnOptions
}
```

---

### `HTMLRevoGridElement` (Extended from `global`)

```ts
interface HTMLRevoGridElement {
  exportExcel?: ExcelConfig;
  'export-excel'?: ExcelConfig
}
```

---

### `HTMLRevoGridElementEventMap` (Extended from `global`)

```ts
interface HTMLRevoGridElementEventMap {
  /**
       * Event for export excel
       *
       * @example
       * ```typescript
       * grid.addEventListener(EXCEL_EXPORT_EVENT, (event) => {
       *   console.log(event);
       * });
       */
      [EXCEL_EXPORT_EVENT]: ExportExcelEvent | undefined;
  [EXCEL_BEFORE_IMPORT_EVENT]: ExcelCsvBeforeImportEvent;
  [EXCEL_BEFORE_SET_EVENT]: ExcelCsvBeforeSetEvent
}
```

---

### `AdditionalData` (Extended from `@revolist/revogrid`)

```ts
interface AdditionalData {
  /**
       * Additional data property for export excel
       *
       * @deprecated Use `grid.exportExcel` instead.
       *
       * @example
       * ```typescript
       * const grid = document.createElement('revo-grid');
       * grid.additionalData = { excel: { allowDrag: false } };
       * ```
       */
      excel?: ExcelConfig
}
```

## Plugin API

### `createExcelJsExcelExportProvider`

```ts
export function createExcelJsExcelExportProvider(excelJsModule: ExcelJsExcelExportModule): ExcelExportProvider;
```

---

### `createSheetJsExcelExportProvider`

```ts
export function createSheetJsExcelExportProvider(xlsxModule: SheetJsExcelExportModule): ExcelExportProvider;
```

---

### `createWorkbookModuleExcelExportProvider`

```ts
export function createWorkbookModuleExcelExportProvider(workbookModule: WorkbookExportModule): ExcelExportProvider;
```

---

### `ExportExcelPlugin`

The `ExportExcelPlugin` is a plugin for RevoGrid that enables XLSX export and CSV

```ts
class ExportExcelPlugin {
  /**
     * Imports a CSV file into the grid.
     */
  async importFile(
    file: File,
    config: ExcelConfig = this.config,
  );

  isCsv(file: File, allowedExtensions: string[] = ['.csv']);

  /**
     * @deprecated Import is CSV-only. Use `isCsv()` instead.
     */
  isExcel(file: File, allowedExtensions: string[] = ['.csv']);

  async export(config?: ExportExcelEvent): Promise<void>;

  destroy();
}
```

---

### `ExcelCsvBeforeImportEvent`

Detail payload emitted before a CSV import is applied to the grid.

```ts
/**
 * Detail payload emitted before a CSV import is applied to the grid.
 */
export type ExcelCsvBeforeImportEvent = {
  file: File;
  sheetName: string;
  csv: string;
  rows: string[][];
};
```

---

### `ExcelCsvBeforeSetEvent` (Extended from `index.ts`)

Detail payload emitted after CSV rows are mapped to grid row objects and
before the grid source is replaced.

```ts
/**
 * Detail payload emitted after CSV rows are mapped to grid row objects and
 * before the grid source is replaced.
 */
export type ExcelCsvBeforeSetEvent = ExcelCsvBeforeImportEvent & {
  jsonData: DataType[];
};
```

---

### `ExportExcelEvent`

Example usage of the ExportExcelEvent type

**Example:**
```typescript
* const exportConfig: ExportExcelEvent = {
 *   sheetName: 'Property Data', // Specify the name of the Excel sheet
 *   workbookName: 'Properties.xlsx', // Name of the workbook file
 *   writingOptions: {
 *     type: 'file', // Output type
 *     bookType: 'xlsx', // Workbook type
 *     compression: true, // Enable compression
 *     ignoreEC: true, // Ignore Excel compatibility
 *   },
 * };
```

```ts
/**
 * Example usage of the ExportExcelEvent type
 *
 * @example
 * const exportConfig: ExportExcelEvent = {
 *   sheetName: 'Property Data', // Specify the name of the Excel sheet
 *   workbookName: 'Properties.xlsx', // Name of the workbook file
 *   writingOptions: {
 *     type: 'file', // Output type
 *     bookType: 'xlsx', // Workbook type
 *     compression: true, // Enable compression
 *     ignoreEC: true, // Ignore Excel compatibility
 *   },
 * };
 */
export type ExportExcelEvent = {
  /** The name of the sheet within the workbook. */
  sheetName?: string;
  /** The name of the Excel workbook. Extensionless names receive `.xlsx`. */
  workbookName?: string;
  /** Export provider object or built-in provider id. */
  provider?: ExcelExportProviderRef;
  /**
   * Optional one-off export transforms for the final provider context.
   *
   * These run after built-in feature transforms and after grid-level
   * `grid.exportExcel.exportTransformers`. Use them for app-owned matrix
   * formatting, provider options, or metadata that applies only to this export
   * call and cannot live on a column definition.
   */
  exportTransformers?: ExcelExportContextTransformer[];
  /**
   * Infer provider options such as column widths and sticky row/column counts
   * from current grid state. Defaults to `true`.
   */
  deriveGridOptions?: boolean;
  /** Provider-specific options forwarded to the selected workbook provider. */
  providerOptions?: Record<string, unknown>;
  /** Options for how the selected provider writes the workbook file. */
  writingOptions?: ExcelExportWritingOptions;
};
```

---

### `ExcelExportCellValue`

Primitive value shape accepted by the Excel export cell formatting pipeline.

```ts
/**
 * Primitive value shape accepted by the Excel export cell formatting pipeline.
 */
export type ExcelExportCellValue = string | number | boolean | Date | null | undefined;
```

---

### `ExcelExportCellStyle`

Workbook-oriented cell style options shared by the bundled writer and optional
provider adapters.

Providers map this structural shape to their own workbook library. Unsupported
fields can be ignored by custom providers without changing the export context.

```ts
/**
 * Workbook-oriented cell style options shared by the bundled writer and optional
 * provider adapters.
 *
 * Providers map this structural shape to their own workbook library. Unsupported
 * fields can be ignored by custom providers without changing the export context.
 */
export type ExcelExportCellStyle = {
  fontFamily?: string;
  fontSize?: number;
  fontWeight?: 'bold';
  fontStyle?: 'italic';
  textDecoration?: {
    strikethrough?: boolean;
    underline?: true;
    doubleUnderline?: true;
  };
  textColor?: string;
  backgroundColor?: string;
  fillPatternStyle?: string;
  fillPatternColor?: string;
  borderColor?: string;
  borderStyle?: string;
  leftBorderColor?: string;
  leftBorderStyle?: string;
  rightBorderColor?: string;
  rightBorderStyle?: string;
  topBorderColor?: string;
  topBorderStyle?: string;
  bottomBorderColor?: string;
  bottomBorderStyle?: string;
  align?: 'left' | 'center' | 'right';
  alignVertical?: 'top' | 'center' | 'bottom';
  height?: number;
  columnSpan?: number;
  rowSpan?: number;
  indent?: number;
  wrap?: boolean;
  textRotation?: number;
  format?: string;
};
```

---

### `ExcelExportCell` (Extended from `index.ts`)

Provider-ready cell object used in `ExcelExportProviderContext.cellRows`.

Additional provider-specific fields are allowed so apps can add metadata for
custom providers through column callbacks or export transformers.

```ts
/**
 * Provider-ready cell object used in `ExcelExportProviderContext.cellRows`.
 *
 * Additional provider-specific fields are allowed so apps can add metadata for
 * custom providers through column callbacks or export transformers.
 */
export type ExcelExportCell = ExcelExportCellStyle & {
  value: ExcelExportCellValue;
  [option: string]: unknown;
};
```

---

### `ExcelExportCellData`

One matrix entry passed to workbook providers.

`null` and `undefined` are reserved for intentional blank cells or span
placeholders created by feature-owned export transforms.

```ts
/**
 * One matrix entry passed to workbook providers.
 *
 * `null` and `undefined` are reserved for intentional blank cells or span
 * placeholders created by feature-owned export transforms.
 */
export type ExcelExportCellData = ExcelExportCell | null | undefined;
```

---

### `ExcelExportCellPropertiesResult`

Return value accepted from column-level Excel export callbacks.

Return a primitive to replace the cell value, a partial cell object to apply
value/style options, or `undefined` to keep the prepared cell unchanged.

```ts
/**
 * Return value accepted from column-level Excel export callbacks.
 *
 * Return a primitive to replace the cell value, a partial cell object to apply
 * value/style options, or `undefined` to keep the prepared cell unchanged.
 */
export type ExcelExportCellPropertiesResult =
  | ExcelExportCellValue
  | (Partial<ExcelExportCell> & Record<string, unknown>)
  | void;
```

---

### `ExcelExportCellPropertiesContext`

Context passed to `column.excelExport.cellProperties` for body and pinned
rows during export preparation.

```ts
/**
 * Context passed to `column.excelExport.cellProperties` for body and pinned
 * rows during export preparation.
 */
export type ExcelExportCellPropertiesContext = {
  value: ExcelExportCellValue;
  rawValue: unknown;
  model: DataType;
  rowIndex: number;
  rowType: DimensionRows;
  column: ColumnRegular;
  columnIndex: number;
  revogrid: HTMLRevoGridElement;
  providers: PluginProviders;
};
```

---

### `ExcelExportColumnPropertiesContext`

Context passed to `column.excelExport.columnProperties` for the generated
column/header row.

```ts
/**
 * Context passed to `column.excelExport.columnProperties` for the generated
 * column/header row.
 */
export type ExcelExportColumnPropertiesContext = {
  value: string;
  column: ColumnRegular;
  columnIndex: number;
  revogrid: HTMLRevoGridElement;
  providers: PluginProviders;
};
```

---

### `ExcelExportCellProperties`

Column-level callback for formatting exported body or pinned-row cells.

```ts
/**
 * Column-level callback for formatting exported body or pinned-row cells.
 */
export type ExcelExportCellProperties = (
  context: ExcelExportCellPropertiesContext,
) => ExcelExportCellPropertiesResult;
```

---

### `ExcelExportColumnProperties`

Column-level callback for formatting the generated exported column/header
cell.

```ts
/**
 * Column-level callback for formatting the generated exported column/header
 * cell.
 */
export type ExcelExportColumnProperties = (
  context: ExcelExportColumnPropertiesContext,
) => ExcelExportCellPropertiesResult;
```

---

### `ExcelExportColumnOptions`

Excel export-only column options.

These options affect exported workbook cells only; rendered grid cells should
use the normal RevoGrid `cellTemplate` and `cellProperties` APIs.

```ts
/**
 * Excel export-only column options.
 *
 * These options affect exported workbook cells only; rendered grid cells should
 * use the normal RevoGrid `cellTemplate` and `cellProperties` APIs.
 */
export type ExcelExportColumnOptions = {
  /**
   * Format or replace an exported body/pinned cell. Returning a cell object
   * without `value` keeps the prepared value and applies the returned options.
   */
  cellProperties?: ExcelExportCellProperties;
  /**
   * Format or replace the generated column/header cell for this column.
   */
  columnProperties?: ExcelExportColumnProperties;
};
```

---

### `WRITE_EXCEL_FILE_PROVIDER_ID`

Built-in provider id for the bundled `write-excel-file` adapter.

```ts
WRITE_EXCEL_FILE_PROVIDER_ID: string;
```

---

### `BuiltInExcelExportProviderId`

```ts
export type BuiltInExcelExportProviderId = typeof WRITE_EXCEL_FILE_PROVIDER_ID;
```

---

### `ExcelExportSourceRow`

Original source-row metadata paired with each exported data row.

Providers and transformers can use this to distinguish body, pinned-top, and
pinned-bottom rows without reading rendered DOM state.

```ts
/**
 * Original source-row metadata paired with each exported data row.
 *
 * Providers and transformers can use this to distinguish body, pinned-top, and
 * pinned-bottom rows without reading rendered DOM state.
 */
export type ExcelExportSourceRow = {
  model: DataType;
  rowIndex: number;
  rowType: DimensionRows;
};
```

---

### `ExcelExportContextTransformResult`

Partial update returned by an `ExcelExportContextTransformer`.

Omitted fields leave the current export context unchanged. Returned
`cellRows` replace the matrix, while option and metadata objects are merged
with the existing context.

**@public**

```ts
/**
 * Partial update returned by an `ExcelExportContextTransformer`.
 *
 * Omitted fields leave the current export context unchanged. Returned
 * `cellRows` replace the matrix, while option and metadata objects are merged
 * with the existing context.
 *
 * @public
 */
export type ExcelExportContextTransformResult = {
  /**
   * Replace the provider-ready matrix after export preparation.
   *
   * The matrix includes all generated header rows before source data rows.
   */
  cellRows?: ExcelExportCellData[][];
  /**
   * Merge additional provider options into the export context.
   *
   * Use this for options consumed by the selected workbook provider.
   */
  providerOptions?: Record<string, unknown>;
  /**
   * Merge derived grid options such as freeze panes or column widths.
   *
   * Provider implementations can combine these with explicit provider options.
   */
  gridDerivedOptions?: Record<string, unknown>;
  /**
   * Merge provider-agnostic metadata for custom workbook providers.
   *
   * Built-in transforms use this to expose details such as grouped headers and
   * cell merge ranges to providers that can map them natively.
   */
  exportMetadata?: Record<string, unknown>;
};
```

---

### `ExcelExportContextTransformer`

Synchronous hook for the final Excel export context before provider output.

Transformers run after RevoGrid data collection, column/header formatting,
and built-in Pro transforms. Grid-level transformers configured on
`grid.exportExcel.exportTransformers` run first; one-off transformers passed
to `plugin.export({ exportTransformers })` run after them.

A transformer can mutate `context` directly, return a partial
`ExcelExportContextTransformResult`, or do both. Use `context.cellRows` for
provider-ready formatted output and `context.rows` only when plain row data is
sufficient.

**@public**

```ts
/**
 * Synchronous hook for the final Excel export context before provider output.
 *
 * Transformers run after RevoGrid data collection, column/header formatting,
 * and built-in Pro transforms. Grid-level transformers configured on
 * `grid.exportExcel.exportTransformers` run first; one-off transformers passed
 * to `plugin.export({ exportTransformers })` run after them.
 *
 * A transformer can mutate `context` directly, return a partial
 * `ExcelExportContextTransformResult`, or do both. Use `context.cellRows` for
 * provider-ready formatted output and `context.rows` only when plain row data is
 * sufficient.
 *
 * @public
 */
export type ExcelExportContextTransformer = (
  context: ExcelExportProviderContext,
) => void | ExcelExportContextTransformResult;
```

---

### `ExcelExportProviderContext`

Full provider handoff context created by `ExportExcelPlugin`.

Custom providers should consume this data-source-based context instead of
reading rendered grid rows. Virtualized offscreen rows are included in
`rows`, `sourceRows`, and `cellRows`.

```ts
/**
 * Full provider handoff context created by `ExportExcelPlugin`.
 *
 * Custom providers should consume this data-source-based context instead of
 * reading rendered grid rows. Virtualized offscreen rows are included in
 * `rows`, `sourceRows`, and `cellRows`.
 */
export type ExcelExportProviderContext = {
  /** Grid element that initiated the export. */
  revogrid: HTMLRevoGridElement;
  /** Runtime providers for advanced integrations that need grid stores or column metadata. */
  providers: PluginProviders;
  /** Original export call configuration, if provided. */
  config?: ExportExcelEvent;
  /** Excel-safe worksheet name after defaulting and normalization. */
  sheetName: string;
  /** Workbook filename after defaulting and extension normalization. */
  workbookName: string;
  /** Requested workbook type. The bundled provider accepts only `xlsx`. */
  bookType: BookType;
  /** Export columns in provider order, including pinned/start/body/end column segments. */
  columns: ColumnRegular[];
  /** Human-readable first row generated from column names. */
  headerRow: string[];
  /**
   * Export data rows keyed by column prop.
   *
   * Rows are collected from the grid data stores in pinned-top, body,
   * pinned-bottom order. This is data-source based and includes virtualized
   * rows that may not be rendered in the DOM.
   *
   * Workbook providers that need formatting, spans, or grouped headers should
   * prefer `cellRows`, which contains the provider-ready matrix.
   */
  rows: DataType[];
  /** Source row metadata in the same order as `rows`. */
  sourceRows: ExcelExportSourceRow[];
  /** Number of generated header rows before data rows in `cellRows`. */
  headerRowsCount: number;
  /** Provider-ready cell matrix with generated headers before data rows. */
  cellRows: ExcelExportCellData[][];
  /** Provider-specific options passed through from `ExportExcelEvent.providerOptions`. */
  providerOptions?: Record<string, unknown>;
  /**
   * Provider options inferred from current grid state, such as column widths
   * and pinned row/column freeze counts. Explicit `providerOptions` may
   * override these in providers that support merging.
   */
  gridDerivedOptions?: Record<string, unknown>;
  /**
   * Feature-owned metadata for custom providers. Built-in providers consume the
   * prepared `cellRows`; optional providers may read metadata such as merge
   * ranges or grouped header details when they can map them natively.
   */
  exportMetadata?: Record<string, unknown>;
  /** Workbook-library writing options passed through for optional adapters. */
  writingOptions?: ExcelExportWritingOptions;
};
```

---

### `ExcelExportProvider`

Workbook provider contract used by `ExportExcelPlugin`.

Implement this interface directly for app-owned workbook libraries or use one
of the optional provider factories for common adapters.

```ts
/**
 * Workbook provider contract used by `ExportExcelPlugin`.
 *
 * Implement this interface directly for app-owned workbook libraries or use one
 * of the optional provider factories for common adapters.
 */
export type ExcelExportProvider = {
  id?: string;
  /**
   * Writes or downloads an exported workbook.
   *
   * Providers receive prepared rows, columns, names, and options. They should
   * not read rendered DOM rows because virtualization may omit offscreen data.
   */
  export(context: ExcelExportProviderContext): void | Promise<void>;
};
```

---

### `ExcelExportProviderRef`

Provider selection value accepted by `ExportExcelEvent.provider` and
`grid.exportExcel.exportProvider`.

```ts
/**
 * Provider selection value accepted by `ExportExcelEvent.provider` and
 * `grid.exportExcel.exportProvider`.
 */
export type ExcelExportProviderRef = BuiltInExcelExportProviderId | ExcelExportProvider;
```

---

### `BookType`

```ts
export type BookType = 'xlsx' | 'xlsm' | 'xlsb' | 'xls' | 'xla' | 'biff8' | 'biff5' | 'biff2' | 'xlml' | 'ods' | 'fods' | 'csv' | 'txt' | 'sylk' | 'slk' | 'html' | 'dif' | 'rtf' | 'prn' | 'eth' | 'dbf';
```

---

### `Properties`

Basic File Properties

```ts
interface Properties {
  /** Summary tab "Title" */
    Title?: string;
  /** Summary tab "Subject" */
    Subject?: string;
  /** Summary tab "Author" */
    Author?: string;
  /** Summary tab "Manager" */
    Manager?: string;
  /** Summary tab "Company" */
    Company?: string;
  /** Summary tab "Category" */
    Category?: string;
  /** Summary tab "Keywords" */
    Keywords?: string;
  /** Summary tab "Comments" */
    Comments?: string;
  /** Statistics tab "Last saved by" */
    LastAuthor?: string;
  /** Statistics tab "Created" */
    CreatedDate?: Date
}
```

---

### `ExcelExportWritingOptions`

```ts
export type ExcelExportWritingOptions = {
  /** Output data encoding */
  type?: 'base64' | 'binary' | 'buffer' | 'file' | 'array' | 'string';

  /**
   * Generate Shared String Table
   * @default false
   */
  bookSST?: boolean;

  /**
   * File format of generated workbook
   * @default 'xlsx'
   */
  bookType?: BookType;

  /**
   * Use ZIP compression for ZIP-based formats
   * @default false
   */
  compression?: boolean;

  /**
   * Suppress "number stored as text" errors in generated files
   * @default true
   */
  ignoreEC?: boolean;

  /** Override workbook properties on save */
  Props?: Properties;

  /** Base64 encoding of NUMBERS base for exports */
  numbers?: string;
};
```

---

### `ExcelJsExcelExportModule`

Structural subset of the ExcelJS module consumed by
`createExcelJsExcelExportProvider()`.

RevoGrid Pro keeps ExcelJS optional. Callers pass their installed module into
the provider factory so the Pro package does not add ExcelJS to every bundle.

```ts
/**
 * Structural subset of the ExcelJS module consumed by
 * `createExcelJsExcelExportProvider()`.
 *
 * RevoGrid Pro keeps ExcelJS optional. Callers pass their installed module into
 * the provider factory so the Pro package does not add ExcelJS to every bundle.
 */
export type ExcelJsExcelExportModule = {
  Workbook: new () => ExcelJsWorkbook;
};
```

---

### `ExcelJsWorkbook`

```ts
export type ExcelJsWorkbook = {
  addWorksheet(
    sheetName: string,
    options?: Record<string, unknown>,
  ): ExcelJsWorksheet;
  xlsx: {
    writeBuffer?(
      writingOptions?: ExcelExportWritingOptions,
    ): Promise<ArrayBuffer | BlobPart> | ArrayBuffer | BlobPart;
    writeFile?(
      workbookName: string,
      writingOptions?: ExcelExportWritingOptions,
    ): Promise<unknown> | unknown;
  };
};
```

---

### `ExcelJsWorksheet`

```ts
export type ExcelJsWorksheet = {
  addRow(values: unknown[]): ExcelJsRow;
  getColumn?(index: number): ExcelJsColumn;
  mergeCells?(
    startRow: number,
    startColumn: number,
    endRow: number,
    endColumn: number,
  ): void;
  views?: Record<string, unknown>[];
};
```

---

### `ExcelJsRow`

```ts
export type ExcelJsRow = {
  getCell(index: number): ExcelJsCell;
  height?: number;
};
```

---

### `ExcelJsCell`

```ts
export type ExcelJsCell = {
  value?: unknown;
  font?: Record<string, unknown>;
  fill?: Record<string, unknown>;
  alignment?: Record<string, unknown>;
  border?: Record<string, unknown>;
  numFmt?: string;
};
```

---

### `ExcelJsColumn`

```ts
export type ExcelJsColumn = {
  width?: number;
};
```

---

### `SheetJsExcelExportModule`

Structural subset of the SheetJS `xlsx` module consumed by
`createSheetJsExcelExportProvider()`.

RevoGrid Pro does not import or bundle SheetJS. Applications that need this
adapter install `xlsx` themselves and pass the module object into the factory.

```ts
/**
 * Structural subset of the SheetJS `xlsx` module consumed by
 * `createSheetJsExcelExportProvider()`.
 *
 * RevoGrid Pro does not import or bundle SheetJS. Applications that need this
 * adapter install `xlsx` themselves and pass the module object into the factory.
 */
export type SheetJsExcelExportModule = {
  utils: {
    book_new(): unknown;
    json_to_sheet(
      data: DataType[],
      options?: Record<string, unknown>,
    ): unknown;
    book_append_sheet(workbook: unknown, worksheet: unknown, sheetName: string): void;
  };
  writeFile(
    workbook: unknown,
    workbookName: string,
    writingOptions?: ExcelExportWritingOptions,
  ): void;
};
```

---

### `WorkbookExportModule`

Minimal workbook module adapter for libraries that can build a workbook from
plain row objects.

This is intentionally smaller than the provider context. Use a custom
`ExcelExportProvider` when a workbook library needs formatted `cellRows`,
merge metadata, grouped headers, or library-specific setup.

```ts
/**
 * Minimal workbook module adapter for libraries that can build a workbook from
 * plain row objects.
 *
 * This is intentionally smaller than the provider context. Use a custom
 * `ExcelExportProvider` when a workbook library needs formatted `cellRows`,
 * merge metadata, grouped headers, or library-specific setup.
 */
export type WorkbookExportModule = {
  createWorkbook(): unknown;
  createWorksheet(
    data: DataType[],
    options?: Record<string, unknown>,
  ): unknown;
  appendWorksheet(workbook: unknown, worksheet: unknown, sheetName: string): void;
  writeFile(
    workbook: unknown,
    workbookName: string,
    writingOptions?: ExcelExportWritingOptions,
  ): void;
};
```

---

### `createDateExcelExportCellProperties`

Create a reusable `excelExport.cellProperties` callback for date columns.

The callback converts valid date-like values into Excel date cells and keeps
empty, invalid, or unsupported values unchanged. Use this helper when you
want to compose the callback into a larger column export configuration.

```ts
export function createDateExcelExportCellProperties(
  options: DateColumnExcelExportOptions =;
```

---

### `createDateExcelExportColumnOptions`

Create column-level Excel export options for date columns.

Valid `Date`, ISO date-only strings, parseable date strings, and numeric date
values are exported as workbook date cells with the configured `format`.
Unsupported values are returned unchanged so the export pipeline keeps the
source value instead of producing an invalid date.

```ts
export function createDateExcelExportColumnOptions(
  options: DateColumnExcelExportOptions =;
```

---

### `DateColumnExcelExportOptions`

Options for date-column Excel export helpers.

The helpers do not import `@revolist/revogrid-column-date`; callers pass
column metadata and the desired workbook date format explicitly.

```ts
/**
 * Options for date-column Excel export helpers.
 *
 * The helpers do not import `@revolist/revogrid-column-date`; callers pass
 * column metadata and the desired workbook date format explicitly.
 */
export type DateColumnExcelExportOptions = {
  /**
   * Column metadata from the date column.
   *
   * Reserved for future date-package metadata while keeping a consistent
   * options shape with other external column-type export helpers.
   */
  column?: ColumnRegular;
  /**
   * Excel date number format applied to converted date cells.
   *
   * Defaults to `yyyy-mm-dd`.
   */
  format?: string;
};
```

---

### `createNumeralExcelExportCellProperties`

Create a reusable `excelExport.cellProperties` callback for numeral columns.

The callback converts finite numbers and numeric strings into Excel number
cells, applies the inferred or explicit format, and right-aligns converted
values. Non-numeric values are returned unchanged so the export pipeline
preserves the original cell content.

```ts
export function createNumeralExcelExportCellProperties(
  options: NumeralColumnExcelExportOptions =;
```

---

### `createNumeralExcelExportColumnOptions`

Create column-level Excel export options for numeral columns.

Use this when wiring an external numeral column type to Excel export through
`column.excelExport`. The returned options contain the same callback as
`createNumeralExcelExportCellProperties`.

```ts
export function createNumeralExcelExportColumnOptions(
  options: NumeralColumnExcelExportOptions =;
```

---

### `NumeralColumnExcelExportOptions`

Options for numeral-column Excel export helpers.

These helpers mirror the external numeral column type at export time without
importing the column-type package. Pass the grid column and active
`columnTypes` map when the export format should be inferred from runtime
column-type metadata.

```ts
/**
 * Options for numeral-column Excel export helpers.
 *
 * These helpers mirror the external numeral column type at export time without
 * importing the column-type package. Pass the grid column and active
 * `columnTypes` map when the export format should be inferred from runtime
 * column-type metadata.
 */
export type NumeralColumnExcelExportOptions = {
  /**
   * Column metadata for the exported numeral column.
   *
   * When `format` is not provided, the helper reads `column.columnType` and
   * looks for a matching `numberFormat` value in `columnTypes`.
   */
  column?: ColumnRegular;
  /**
   * Grid column type registry used to infer the Excel number format.
   *
   * Only the matching column type's `numberFormat` string is read. Other
   * metadata stays owned by the runtime column type.
   */
  columnTypes?: ColumnTypes;
  /**
   * Excel number format applied to converted numeric cells.
   *
   * Defaults to the external numeral column type format, `0,0[.]00`.
   */
  format?: string;
};
```

---

### `createSelectExcelExportCellProperties`

Create a reusable `excelExport.cellProperties` callback for select columns.

The callback exports the user-facing label for a stored select value. If no
lookup or source match is available, the original value is converted to a
supported Excel cell primitive and exported unchanged semantically.

```ts
export function createSelectExcelExportCellProperties(;
```

---

### `createSelectExcelExportColumnOptions`

Create column-level Excel export options for select columns.

Use this when wiring an external select column type to Excel export through
`column.excelExport`. The returned options contain the same callback as
`createSelectExcelExportCellProperties`.

```ts
export function createSelectExcelExportColumnOptions(
  options: SelectColumnExcelExportOptions,
): ExcelExportColumnOptions;
```

---

### `SelectSourceEntry`

A select-column source entry that can be exported as either a direct label or
an object resolved through `labelKey` and `valueKey`.

```ts
/**
 * A select-column source entry that can be exported as either a direct label or
 * an object resolved through `labelKey` and `valueKey`.
 */
export type SelectSourceEntry = string | Record<string, unknown>;
```

---

### `SelectColumnMetadata` (Extended from `index.ts`)

Minimal select-column metadata required to resolve exported labels.

The type intentionally captures only the public metadata used by the
external select column type, allowing Excel export integrations to resolve
labels without importing the select package.

```ts
/**
 * Minimal select-column metadata required to resolve exported labels.
 *
 * The type intentionally captures only the public metadata used by the
 * external select column type, allowing Excel export integrations to resolve
 * labels without importing the select package.
 */
export type SelectColumnMetadata = ColumnRegular & {
  /**
   * Select options shown by the runtime column type.
   *
   * String entries are exported directly. Object entries are matched through
   * `valueKey` and exported through `labelKey`.
   */
  source?: SelectSourceEntry[];
  /**
   * Optional precomputed lookup by source value.
   *
   * When present, it is checked before scanning `source` and is useful for
   * large option lists.
   */
  sourceLookup?: Record<string, unknown>;
  /**
   * Object key that contains the human-readable export label.
   */
  labelKey?: string;
  /**
   * Object key that contains the stored cell value.
   */
  valueKey?: string;
};
```

---

### `SelectColumnExcelExportOptions`

Options for select-column Excel export helpers.

```ts
/**
 * Options for select-column Excel export helpers.
 */
export type SelectColumnExcelExportOptions = {
  /**
   * Select column metadata used to translate stored values into labels.
   */
  column: SelectColumnMetadata;
};
```

---

### `ExcelConfig`

```ts
export type ExcelConfig = {

  /** Allow CSV drag and drop files to the grid area. Default: `true`. */
  allowDrag?: boolean;

  /**
   * Grid-level default export provider.
   *
   * `plugin.export({ provider })` still wins for one-off exports. When omitted,
   * the bundled `write-excel-file` provider is used.
   */
  exportProvider?: ExcelExportProviderRef;

  /**
   * Grid-level Excel export transforms for every export call.
   *
   * These run after the plugin prepares the provider context and applies
   * built-in Pro transforms, but before one-off
   * `plugin.export({ exportTransformers })` transforms. Use them for
   * application-wide workbook formatting, provider-option defaults, or
   * provider metadata that should apply consistently to all Excel exports.
   */
  exportTransformers?: ExcelExportContextTransformer[];

  /**
   * Keep existing grid columns during CSV import instead of generating columns
   * from the first CSV row. Default: `false`.
   */
  skipColumnGeneration?: boolean;

  /** Allowed file extensions for CSV import. Default: `['.csv']`. */
  allowedExtensions?: string[];
};
```
