# Configuring Export

Canonical page: https://www.adaptabletools.com/docs/handbook-exporting-configuring

- Developers can configure Export at design time in multiple ways

There are many aspects of Export that can be configured by developers, primarily through properties in [Export Options](https://www.adaptabletools.com/docs/technical-reference-exporting/index.md), or functions in [Export API](https://www.adaptabletools.com/docs/technical-reference-exporting/index.md).

[`ExportOptions`](https://www.adaptabletools.com/docs/reference/exportoptions.md) defines **fourteen** properties:

| Property                   | Section                                                                                                                |
| -------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `exportDataFormat`         | [Formatting Report Data](https://www.adaptabletools.com/docs/handbook-exporting-formatting-reports/index.md)                             |
| `exportDateFormat`         | [Formatting Report Data](https://www.adaptabletools.com/docs/handbook-exporting-formatting-reports/index.md)                             |
| `customDestinations`       | [Custom Export Destinations](https://www.adaptabletools.com/docs/handbook-exporting-destinations-custom/index.md)                        |
| `systemReportNames`        | [Reports](https://www.adaptabletools.com/docs/handbook-exporting-reports/index.md)                                                       |
| `systemReportFormats`      | [Report Format Types](https://www.adaptabletools.com/docs/handbook-exporting-reports-format-type/index.md)                               |
| `systemExportDestinations` | [Export Destinations](https://www.adaptabletools.com/docs/handbook-exporting-destinations/index.md)                                      |
| `appendFileTimestamp`      | Configuring Report File Names                                                                                          |
| `reportFilename`           | Configuring Report File Names                                                                                          |
| `isColumnExportable`       | Setting Exportable Columns                                                                                             |
| `csvSeparator`             | [Report Format Type — CSV](https://www.adaptabletools.com/docs/handbook-exporting-reports-format-type-csv/index.md)                      |
| `skipColumnHeaders`        | Skipping Column Headers                                                                                                |
| `getDetailRows`            | [Exporting Detail Rows](https://www.adaptabletools.com/docs/handbook-master-detail/index.md#exporting-detail-rows)            |
| `processExport`            | [Processing Reports](https://www.adaptabletools.com/docs/handbook-exporting-processing/index.md)                                         |
| `excelSheetName`           | [Report Format Type — Excel](https://www.adaptabletools.com/docs/handbook-exporting-reports-format-type-excel/index.md#excel-sheet-name) |

## Advanced Exporting

By default Export will send the report to the desired destination in a straightforward way.

For instance exporting to Excel will create a new workbook with default worksheet settings.

However sometimes users want more fine-grained control over the Exported file, e.g. to freeze the header row, protect the worksheet, or change the font in Excel.

There are 2 ways to provide this:

- for **every** Export, through AG Grid's default export params
- for a **single** Export, through the `exportConfig` argument of the `exportReport` function in [Export API](https://www.adaptabletools.com/docs/technical-reference-exporting/index.md)

### AG Grid Default Export Params

AG Grid's `defaultExcelExportParams` and `defaultCsvExportParams` GridOptions properties provide settings for every Excel and CSV Export (see [Excel Export API](https://www.ag-grid.com/javascript-data-grid/excel-export-api/) and [CSV Export](https://www.ag-grid.com/javascript-data-grid/csv-export/)).

AdapTable applies them to all Exports, wherever they are run from (e.g. the Export Toolbar, Context Menu, Export API or a Scheduled Report), and to the `convertToExcel` and `convertToCsv` functions used in [Processing Reports](https://www.adaptabletools.com/docs/handbook-exporting-processing/index.md).

Commonly used Excel settings include:

- `freezeRows` - freezes the header row (`'headers'`), or the header row and the top pinned rows (`'headersAndPinnedRows'`); see [Excel Export: Freezing](https://www.ag-grid.com/javascript-data-grid/excel-export-freeze/)
- `freezeColumns` - freezes the left pinned columns (`'pinned'`)
- `protectSheet` - protects the worksheet, optionally with a password; see [Excel Export: Data Protection](https://www.ag-grid.com/javascript-data-grid/excel-export-data-protection/)
- `author`, `fontSize`, `headerRowHeight` and `rowHeight`

```ts {2-9}
const gridOptions: GridOptions = {
  defaultExcelExportParams: {
    freezeRows: 'headers',
    freezeColumns: 'pinned',
    protectSheet: true,
  },
  defaultCsvExportParams: {
    prependContent: 'Trades Report',
  },
};
```

AdapTable sets the exported columns, rows and cell values, the file name, the sheet name and the CSV separator for every Export, so these params are ignored in the default export params: `columnKeys`, `exportedRows`, `shouldRowBeSkipped`, `skipRowGroups`, `rowGroupExpandState`, `fileName`, `skipColumnHeaders`, `getCustomContentBelowRow`, `processCellCallback`, `processRowGroupCallback`, `sheetName`, `processNoteCallback` and `columnSeparator`.

Use the Export Options instead (e.g. `reportFilename`, `skipColumnHeaders`, `excelSheetName` and `csvSeparator`), or `exportConfig` for a single Export.

The `convertToExcel` and `convertToCsv` functions also use the `skipColumnHeaders`, `excelSheetName` and `csvSeparator` Export Options.

JSON Exports ignore `defaultCsvExportParams`

`convertToExcel` creates the file from the Report Data only, which has no pinned columns or pinned rows, so there `freezeColumns: 'pinned'` freezes nothing and `freezeRows: 'headersAndPinnedRows'` freezes only the header row

### Export Config

The `exportReport` function in [Export API](https://www.adaptabletools.com/docs/technical-reference-exporting/index.md) takes an optional `exportConfig` argument which allows developers to modify the params of a single Export.

Params set here override both AdapTable's params and AG Grid's default export params (they are not used when `processExport` returns the Report itself).

### `exportReport`

Exports a Report (with fine-grained control if needed)

This function allows developers, at run time, to export Reports in AdapTable to any destination.

It also provides them with very fine-grained control over the Export.

The function definition is:

```
exportReport(name: ReportNameType, format: ReportFormatType, destination?: ExportDestinationType, config?: ExportConfig
): Promise<void>;
```

<b>Basic Exporting</b>

You can use this function to export a report to a destination of your choice.

```ts {2}
// Export the Current Layout in Visual Export format as a downloadable file
adaptableApi.exportApi.exportReport('Current Layout', 'Excel', 'Download');
```

<b>Advanced Exporting</b>

The function also allows developers to configure the Export in much more depth.

This is due to the `exportConfig` property, which is of type [`ExportConfig`](https://www.adaptabletools.com/docs/reference/exportconfig.md), and defined as follows:

| Property | Type | Description |
| --- | --- | --- |
| [exportParams](https://www.adaptabletools.com/docs/reference/exportconfig.md#exportparams) | `(defaultExportParams: `[`CustomExportParams`](https://www.adaptabletools.com/docs/reference/customexportparams.md)`) => `[`CustomExportParams`](https://www.adaptabletools.com/docs/reference/customexportparams.md) | Function to modify export params; receives default params &amp; returns modified params |
| [showProgressIndicator](https://www.adaptabletools.com/docs/reference/exportconfig.md#showprogressindicator) | `boolean` | Whether to show progress indicator |

The `exportParams` property is a function which enables overriding of AdapTable's default export behaviour.

It receives default params (of type `CustomExportParams`) and returns modified params (also of type `CustomExportParams`):

```
exportParams?: (defaultExportParams: CustomExportParams) => CustomExportParams;
```

The [`CustomExportParams`](https://www.adaptabletools.com/docs/reference/customexportparams.md) object can be one of two AG Grid objects:

- `ExcelExportParams` - used for Excel format exports
- `CsvExportParams` - used for CSV, JSON and any custom format exports

```ts {2}
// Export to Excel but configure the Workbook and Worksheet to meet precise requirements
adaptableApi.exportApi.exportReport('Current Layout', 'Excel', 'Download', {
  exportParams: (exportParams: ExcelExportParams) => {
    if (!exportParams.processCellCallback) {
      return exportParams;
    }
    const adaptableProcessCellCallback = exportParams.processCellCallback;
    return {
      ...exportParams,
      fileName: 'AdapTable Data',
      author: 'AdapTable Demos',
      fontSize: 13,
      sheetName: 'Current Layout',
      headerRowHeight: 50,
      processCellCallback: params => {
        // inherits adaptable formatting (Column Format, etc.)
        const adaptableCellValue = adaptableProcessCellCallback(params);
        return `Custom ${adaptableCellValue}`;
      },
    };
  },
});
```

**Example: Configuring Export**

Providing fine-grained control over Export in AdapTable

- In this demo we export data to Excel and CSV via the `exportReport` function in Export API (using Custom Toolbar Buttons), allowing us add bespoke config:
  - We export `Current Layout` report to **Excel**, with custom names for Excel Workbook and Worksheet, and changing font and header row height
  - We export `All Data` report to **CSV**, with custom filename and separator

Demo project (Vanilla); the files without a marker are shown below:

```text
src/
  adaptableOptions.ts
  agGridModules.ts     [template]
  columnDefs.ts        [template]
  gridOptions.ts       [template]
  index.ts             [template]
  onAdaptableReady.ts  [template]
  rowData.ts           [template]
  styles.css           [template]
index.html             [template]
package.json           [template]
tsconfig.json          [template]
```

Files marked `[template]` are the same in every demo; see the [demo template](https://www.adaptabletools.com/llms/demo-template.md#vanilla).

**`src/adaptableOptions.ts`**

```ts
import {
  AdaptableButton,
  AdaptableOptions,
  CustomExportParams,
  CustomToolbarButtonContext,
  GridCellRange,
} from '@adaptabletools/adaptable';
import {CsvExportParams, ExcelExportParams} from 'ag-grid-enterprise';
import {WebFramework} from './rowData';

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Exporting Reports with Config',
  dashboardOptions: {
    customToolbars: [
      {
        name: 'ButtonToolbar',
        title: 'Buttons',
        toolbarButtons: [
          {
            label: 'Export to Excel',
            icon: {
              name: 'excel',
            },
            buttonStyle: {
              tone: 'neutral',
              variant: 'outlined',
            },
            onClick: (
              button: AdaptableButton<CustomToolbarButtonContext>,
              context: CustomToolbarButtonContext
            ) => {
              context.adaptableApi.exportApi.exportReport(
                'Current Layout',
                'Excel',
                'Download',
                {
                  exportParams: (exportParams: CustomExportParams) => {
                    if (!exportParams.processCellCallback) {
                      return exportParams;
                    }
                    const adaptableProcessCellCallback =
                      exportParams.processCellCallback;
                    return {
                      ...exportParams,
                      fileName: 'AdapTable Excel Data',
                      author: 'AdapTable Demos',
                      fontSize: 13,
                      sheetName:
                        context.adaptableApi.layoutApi.getCurrentLayoutName(),
                      headerRowHeight: 50,
                      processCellCallback: params => {
                        // inherits adaptable formatting (Column Format, etc.)
                        const adaptableCellValue =
                          adaptableProcessCellCallback(params);
                        return `Custom ${adaptableCellValue}`;
                      },
                    };
                  },
                }
              );
            },
          },
          {
            label: 'Export to CSV',
            icon: {
              name: 'csv',
            },
            buttonStyle: {
              tone: 'neutral',
              variant: 'outlined',
            },
            onClick: (
              button: AdaptableButton<CustomToolbarButtonContext>,
              context: CustomToolbarButtonContext
            ) => {
              context.adaptableApi.exportApi.exportReport(
                'All Data',
                'CSV',
                'Download',
                {
                  exportParams: (defaultExportParams: CustomExportParams) => {
                    if (!defaultExportParams.processCellCallback) {
                      return defaultExportParams;
                    }
                    const adaptableProcessCellCallback =
                      defaultExportParams.processCellCallback;
                    return {
                      ...defaultExportParams,
                      fileName: 'AdapTable CSV Data',
                      author: 'AdapTable Demos',
                      columnSeparator: '|',
                      processCellCallback: params => {
                        // inherits adaptable formatting (Column Format, etc.)
                        const adaptableCellValue =
                          adaptableProcessCellCallback(params);
                        return `Custom ${adaptableCellValue}`;
                      },
                    };
                  },
                }
              );
            },
          },
        ],
      },
    ],
  },
  initialState: {
    Dashboard: {PinnedToolbars: ['ButtonToolbar']},
    Theme: {CurrentTheme: 'dark'},
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'name',
            'language',
            'github_stars',
            'license',
            'has_projects',
            'has_pages',
            'created_at',
            'has_wiki',
            'updated_at',
            'pushed_at',
            'github_watchers',
            'week_issue_change',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
      ],
    },
  },
};
```

## Configuring Report File Names

By default the name of the file created in an Export is that of the exported Report Name (e.g. 'All Data').

There are 2 options available in [Export Options](https://www.adaptabletools.com/docs/technical-reference-exporting/index.md) to change this behaviour:

- `appendFileTimestamp` which appends a Timestamp to the Report name

### `appendFileTimestamp`

Whether to add a timestamp as a suffix to exported file name

The timestamp always takes the form 'yyyyMMdd_HHmmss'.

For example exporting the 'All Data' report on 1 Jan at 10:15 am will produce: 'All_Data_20250101_101500.xls'

```ts {4}
// Add a Timestamp to the name of the exported report
const adaptableOptions: AdaptableOptions = {
  exportOptions: {
    appendFileTimestamp: true,
  },
};
```

- `reportFilename` which allows a completely different Report name to be used

### `reportFilename`

Function enabling bespoke Report file names

Use this property to override AdapTable's default Report file name with a bespoke implementation.

The function receives a [`ReportFileNameContext`](https://www.adaptabletools.com/docs/reference/reportfilenamecontext.md) object and returns a string:

```ts
reportFilename?(reportFileNameContext: ReportFileNameContext): string;
```

The `ReportFileNameContext` object contains just 1 property:

| Property | Type | Description |
| --- | --- | --- |
| [fileName](https://www.adaptabletools.com/docs/reference/reportfilenamecontext.md#filename) | `string` | Default File Name to use |
| [adaptableContext](https://www.adaptabletools.com/docs/reference/reportfilenamecontext.md#adaptablecontext) | `any` | Custom application Context provided in `AdaptableOptions.adaptableContext` |

but also extends [`BaseExportContext`](https://www.adaptabletools.com/docs/reference/baseexportcontext.md)

| Property | Type | Description |
| --- | --- | --- |
| [exportDestination](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#exportdestination) | [`ExportDestinationType`](https://www.adaptabletools.com/docs/reference/exportdestinationtype.md) | Export Destination for the Report |
| [report](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#report) | [`Report`](https://www.adaptabletools.com/docs/reference/report.md) | The Report Configuration being run |
| [reportFormat](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#reportformat) | [`ReportFormatType`](https://www.adaptabletools.com/docs/reference/reportformattype.md) | Format of the Report being run |
| [reportName](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#reportname) | [`ReportNameType`](https://www.adaptabletools.com/docs/reference/reportnametype.md) | Name of the Report being run |
| [adaptableContext](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#adaptablecontext) | `any` | Custom application Context provided in `AdaptableOptions.adaptableContext` |

```ts {4,5,6,7,8,9}
// Change the File Name for "All Data" Report
const adaptableOptions: AdaptableOptions = {
  exportOptions: {
    reportFilename: (reportFileNameContext: ReportFileNameContext) => {
      return reportFileNameContext.reportName == 'All Data'
        ? `Current Grid Data Sent to ${
            reportFileNameContext.destination
          } on ${new Date().toDateString()}`
        : reportFileNameContext.fileName;
    },
  },
};
```

**Example: Configuring Report FileNames**

Configuring the Names of the Report Files in Export

- In this example we provide a custom File Name - but just for the "All Data" Report

Demo project (Vanilla); the files without a marker are shown below:

```text
src/
  adaptableOptions.ts
  agGridModules.ts     [template]
  columnDefs.ts        [template]
  gridOptions.ts       [template]
  index.ts             [template]
  onAdaptableReady.ts  [template]
  rowData.ts           [template]
  styles.css           [template]
index.html             [template]
package.json           [template]
tsconfig.json          [template]
```

Files marked `[template]` are the same in every demo; see the [demo template](https://www.adaptabletools.com/llms/demo-template.md#vanilla).

**`src/adaptableOptions.ts`**

```ts
import {
  AdaptableOptions,
  ReportFileNameContext,
} from '@adaptabletools/adaptable';
import {WebFramework} from './rowData';

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Configuring Report FileName',
  exportOptions: {
    reportFilename: (reportFileNameContext: ReportFileNameContext) => {
      return (
        reportFileNameContext.reportName +
        ' Sent to ' +
        reportFileNameContext.exportDestination +
        ' with format ' +
        reportFileNameContext.reportFormat
      );
    },
  },
  initialState: {
    Dashboard: {
      Tabs: [
        {
          Name: 'Demo',
          Toolbars: ['Export'],
        },
      ],
    },
    StatusBar: {
      StatusBars: [
        {
          Key: 'Center Panel',
          StatusBarPanels: ['Export'],
        },
      ],
    },
    Theme: {CurrentTheme: 'dark'},
    Export: {
      CurrentReport: 'All Data',
      CurrentFormat: 'JSON',
    },
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'name',
            'language',
            'github_stars',
            'license',
            'has_projects',
            'has_pages',
            'created_at',
            'has_wiki',
            'updated_at',
            'pushed_at',
            'github_watchers',
            'week_issue_change',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
      ],
    },
  },
};
```

## Setting Exportable Columns

By default **every** Column in AdapTable is exportable.

This means that it can be included in System Reports (e.g. `All Data`) and will be available in UI for selection.

This can be set to false for any Column via the `isColumnExportable` property in Export Options.

### `isColumnExportable`

Whether a Column is exportable

This property is in the form of a function which takes an [`AdaptableColumnContext`](https://www.adaptabletools.com/docs/reference/adaptablecolumncontext.md) object and returns a Boolean.

```ts
isColumnExportable?: (context: AdaptableColumnContext) => boolean;
```

The `AdaptableColumnContext` simply includes details of the given column to check.

```ts {4}
// Only allow 4 Columns to be included in Reports
const adaptableOptions: AdaptableOptions = {
  exportOptions: {
    isColumnExportable: (context: AdaptableColumnContext) =>
      ['name', 'github_stars', 'language', 'github_watchers'].includes(
        context.column.columnId
      ),
  },
};
```

**Example: Setting Exportable Columns**

Configuring which columns are exportable

- In this example we dont export the `Language` Column, nor any `Date` Columns

Demo project (Vanilla); the files without a marker are shown below:

```text
src/
  adaptableOptions.ts
  agGridModules.ts     [template]
  columnDefs.ts        [template]
  gridOptions.ts       [template]
  index.ts             [template]
  onAdaptableReady.ts  [template]
  rowData.ts           [template]
  styles.css           [template]
index.html             [template]
package.json           [template]
tsconfig.json          [template]
```

Files marked `[template]` are the same in every demo; see the [demo template](https://www.adaptabletools.com/llms/demo-template.md#vanilla).

**`src/adaptableOptions.ts`**

```ts
import {
  AdaptableColumnContext,
  AdaptableOptions,
  BaseExportContext,
} from '@adaptabletools/adaptable';
import {WebFramework} from './rowData';

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Configuring Exportable Columns',
  exportOptions: {
    isColumnExportable: (context: AdaptableColumnContext) =>
      context.column.columnId !== 'language' &&
      context.column.dataType !== 'date',
  },
  initialState: {
    Dashboard: {
      Tabs: [
        {
          Name: 'Demo',
          Toolbars: ['Export'],
        },
      ],
    },
    StatusBar: {
      StatusBars: [
        {
          Key: 'Center Panel',
          StatusBarPanels: ['Export'],
        },
      ],
    },
    Theme: {CurrentTheme: 'dark'},
    Export: {
      CurrentReport: 'All Data',
      CurrentFormat: 'Excel',
    },
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'name',
            'language',
            'github_stars',
            'license',
            'has_projects',
            'has_pages',
            'created_at',
            'has_wiki',
            'updated_at',
            'pushed_at',
            'github_watchers',
            'week_issue_change',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
      ],
    },
  },
};
```

## Skipping Column Headers

By default AdapTable will include the Column Headers in the Export.

This can be set to false all or some Reports via the `skipColumnHeaders` property in Export Options.

### `skipColumnHeaders`

Whether to exclude Column Headers from the exported data

This property is in the form of a boolean or a function which takes an [`BaseExportContext`](https://www.adaptabletools.com/docs/reference/baseexportcontext.md) object and returns a Boolean. When `true`, column headers are omitted from the export.

```ts
skipColumnHeaders?: boolean | ((skipColumnHeadersContext: BaseExportContext) => boolean);
```

The `BaseExportContext` provides details of the report being exported:

| Property | Type | Description |
| --- | --- | --- |
| [exportDestination](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#exportdestination) | [`ExportDestinationType`](https://www.adaptabletools.com/docs/reference/exportdestinationtype.md) | Export Destination for the Report |
| [report](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#report) | [`Report`](https://www.adaptabletools.com/docs/reference/report.md) | The Report Configuration being run |
| [reportFormat](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#reportformat) | [`ReportFormatType`](https://www.adaptabletools.com/docs/reference/reportformattype.md) | Format of the Report being run |
| [reportName](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#reportname) | [`ReportNameType`](https://www.adaptabletools.com/docs/reference/reportnametype.md) | Name of the Report being run |
| [adaptableContext](https://www.adaptabletools.com/docs/reference/baseexportcontext.md#adaptablecontext) | `any` | Custom application Context provided in `AdaptableOptions.adaptableContext` |

```ts {4}
// Don't include Column Header in the All Data Report
const adaptableOptions: AdaptableOptions = {
  exportOptions: {
    skipColumnHeaders: (context: BaseExportContext) => {
      return context.reportName === 'All Data';
    },
  },
};
```

**Example: Skipping Column Headers**

Excluding Column Headers from exported Report

- In this example we exclude Custom Headers from the "All Data" Report only

Demo project (Vanilla); the files without a marker are shown below:

```text
src/
  adaptableOptions.ts
  agGridModules.ts     [template]
  columnDefs.ts        [template]
  gridOptions.ts       [template]
  index.ts             [template]
  onAdaptableReady.ts  [template]
  rowData.ts           [template]
  styles.css           [template]
index.html             [template]
package.json           [template]
tsconfig.json          [template]
```

Files marked `[template]` are the same in every demo; see the [demo template](https://www.adaptabletools.com/llms/demo-template.md#vanilla).

**`src/adaptableOptions.ts`**

```ts
import {AdaptableOptions, BaseExportContext} from '@adaptabletools/adaptable';
import {WebFramework} from './rowData';

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Configuring Report Column Headers',
  exportOptions: {
    skipColumnHeaders: (context: BaseExportContext) => {
      return context.reportName === 'All Data';
    },
  },
  initialState: {
    Dashboard: {
      Tabs: [
        {
          Name: 'Demo',
          Toolbars: ['Export'],
        },
      ],
    },
    StatusBar: {
      StatusBars: [
        {
          Key: 'Center Panel',
          StatusBarPanels: ['Export'],
        },
      ],
    },
    Theme: {CurrentTheme: 'dark'},
    Export: {
      CurrentReport: 'All Data',
      CurrentFormat: 'Excel',
    },
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'name',
            'language',
            'github_stars',
            'license',
            'has_projects',
            'has_pages',
            'created_at',
            'has_wiki',
            'updated_at',
            'pushed_at',
            'github_watchers',
            'week_issue_change',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
      ],
    },
  },
};
```

Master–detail grids need `getDetailRows` to include detail rows in an export — see [Exporting Detail Rows](https://www.adaptabletools.com/docs/handbook-master-detail/index.md#exporting-detail-rows).
