durcno 1.0.0-alpha.0

package/dist/src/migration/ddl.d.mts

@@ -0,0 +1,747 @@
+import { OnDeleteAction } from "../columns/common.mjs";
+import { SnapshotCheckExpr } from "../constraints/check.mjs";
+import { IndexType } from "../indexes.mjs";
+import { Snapshot } from "./snapshot.mjs";
+import { CustomStatement, DDLStatement } from "./statement.mjs";
+
+//#region src/migration/ddl.d.ts
+/**
+ * DDL statement that creates a new PostgreSQL schema.
+ *
+ * Generates: `CREATE SCHEMA <name>;`
+ *
+ * @remarks
+ * Schemas are not tracked in the migration snapshot.
+ *
+ * @example
+ * ```typescript
+ * ddl.createSchema('analytics');
+ * // CREATE SCHEMA analytics;
+ * ```
+ */
+declare class CreateSchemaStatement extends DDLStatement {
+  private readonly schema;
+  readonly type: "createSchema";
+  /**
+   * @param schema - The name of the schema to create.
+   */
+  constructor(schema: string);
+  toSQL(): string;
+  /** Schemas are not tracked in snapshot, so this is a no-op. */
+  applyToSnapshot(_snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that drops an existing PostgreSQL schema.
+ *
+ * Generates: `DROP SCHEMA <name>;`
+ *
+ * @remarks
+ * Schemas are not tracked in the migration snapshot.
+ *
+ * @example
+ * ```typescript
+ * ddl.dropSchema('analytics');
+ * // DROP SCHEMA analytics;
+ * ```
+ */
+declare class DropSchemaStatement extends DDLStatement {
+  private readonly schema;
+  readonly type: "dropSchema";
+  /**
+   * @param schema - The name of the schema to drop.
+   */
+  constructor(schema: string);
+  toSQL(): string;
+  /** Schemas are not tracked in snapshot, so this is a no-op. */
+  applyToSnapshot(_snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that creates a new PostgreSQL enum type.
+ *
+ * Generates: `CREATE TYPE "schema"."name" AS ENUM('val1', 'val2', ...);`
+ *
+ * @example
+ * ```typescript
+ * ddl.createEnum('public', 'user_type', ['admin', 'user', 'guest']);
+ * // CREATE TYPE "public"."user_type" AS ENUM('admin', 'user', 'guest');
+ * ```
+ */
+declare class CreateEnumStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  private readonly values;
+  readonly type: "createEnum";
+  /**
+   * @param schema - The schema the enum belongs to.
+   * @param name - The name of the enum type to create.
+   * @param values - Ordered list of allowed enum values.
+   */
+  constructor(schema: string, name: string, values: string[]);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that adds a value to an existing PostgreSQL enum type.
+ *
+ * Generates: `ALTER TYPE "schema"."name" ADD VALUE IF NOT EXISTS 'value' [AFTER|BEFORE 'ref'];`
+ *
+ * @remarks
+ * PostgreSQL does not support removing values from an enum.
+ * Values can only be added, optionally positioned relative to an existing value.
+ *
+ * @example
+ * ```typescript
+ * // Append a value
+ * ddl.alterEnumAddValue('public', 'user_type', 'moderator');
+ *
+ * // Insert after a specific value
+ * ddl.alterEnumAddValue('public', 'user_type', 'moderator', { after: 'admin' });
+ *
+ * // Insert before a specific value
+ * ddl.alterEnumAddValue('public', 'user_type', 'moderator', { before: 'user' });
+ * ```
+ */
+declare class AlterEnumAddValueStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  private readonly value;
+  private readonly position?;
+  readonly type: "alterEnum";
+  /**
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name.
+   * @param value - The new value to add.
+   * @param position - Optional positioning: `{ after: 'val' }` or `{ before: 'val' }`.
+   */
+  constructor(schema: string, name: string, value: string, position?: {
+    after?: string;
+    before?: string;
+  } | undefined);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that drops an existing PostgreSQL enum type.
+ *
+ * Generates: `DROP TYPE "schema"."name";`
+ *
+ * @example
+ * ```typescript
+ * ddl.dropEnum('public', 'user_type');
+ * // DROP TYPE "public"."user_type";
+ * ```
+ */
+declare class DropEnumStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  readonly type: "dropEnum";
+  /**
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name to drop.
+   */
+  constructor(schema: string, name: string);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * Options for configuring a PostgreSQL sequence.
+ *
+ * @see {@link CreateSequenceStatement}
+ */
+interface SequenceOptions {
+  /** The `START WITH` value for the sequence. */
+  startWith?: number;
+  /** The `INCREMENT BY` value. */
+  increment?: number;
+  /** The minimum value (`MINVALUE`). */
+  minValue?: number;
+  /** The maximum value (`MAXVALUE`). */
+  maxValue?: number;
+  /** Whether the sequence wraps around when it reaches min/max (`CYCLE`). */
+  cycle?: boolean;
+  /** Number of sequence values to pre-allocate (`CACHE`). */
+  cache?: number;
+}
+/**
+ * DDL statement that creates a new PostgreSQL sequence.
+ *
+ * Generates: `CREATE SEQUENCE "schema"."name" [START WITH n] [INCREMENT BY n] ...;`
+ *
+ * @example
+ * ```typescript
+ * ddl.createSequence('public', 'order_seq', {
+ *   startWith: 1000,
+ *   increment: 1,
+ *   cache: 10,
+ * });
+ * // CREATE SEQUENCE "public"."order_seq" START WITH 1000 INCREMENT BY 1 CACHE 10;
+ * ```
+ */
+declare class CreateSequenceStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  private readonly options;
+  readonly type: "createSequence";
+  /**
+   * @param schema - The schema the sequence belongs to.
+   * @param name - The sequence name.
+   * @param options - Optional sequence configuration.
+   */
+  constructor(schema: string, name: string, options?: SequenceOptions);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that drops an existing PostgreSQL sequence.
+ *
+ * Generates: `DROP SEQUENCE "schema"."name";`
+ *
+ * @example
+ * ```typescript
+ * ddl.dropSequence('public', 'order_seq');
+ * // DROP SEQUENCE "public"."order_seq";
+ * ```
+ */
+declare class DropSequenceStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  readonly type: "dropSequence";
+  /**
+   * @param schema - The schema the sequence belongs to.
+   * @param name - The sequence name to drop.
+   */
+  constructor(schema: string, name: string);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * Defines a foreign-key reference from a column to another table's column.
+ *
+ * @see {@link ColumnOptions.references}
+ */
+interface ColumnReference {
+  /** Schema of the referenced table. */
+  schema: string;
+  /** Name of the referenced table. */
+  table: string;
+  /** Name of the referenced column. */
+  column: string;
+  /** The `ON DELETE` action (`CASCADE`, `SET NULL`, `RESTRICT`, etc.). */
+  onDelete: OnDeleteAction;
+}
+/**
+ * Options that can be applied to a column when creating or altering a table.
+ *
+ * @see {@link CreateTableBuilder.column}
+ * @see {@link AlterTableBuilder.addColumn}
+ */
+interface ColumnOptions {
+  /** Add a `NOT NULL` constraint. */
+  notNull?: boolean;
+  /** Make this column the table's primary key. */
+  primaryKey?: boolean;
+  /** Add a `UNIQUE` constraint. */
+  unique?: boolean;
+  /** A raw SQL expression for the `DEFAULT` clause. */
+  default?: string;
+  /** The `GENERATED` strategy (`"ALWAYS"` or `"BY DEFAULT"`). */
+  generated?: string;
+  /** The `AS` expression for generated columns. */
+  as?: string;
+  /** A foreign-key reference to another table's column. */
+  references?: ColumnReference;
+}
+/**
+ * Chainable builder that constructs a `CREATE TABLE` DDL statement.
+ *
+ * Use {@link ddl.createTable} to obtain an instance, then chain
+ * `.column()`, `.check()`, `.uniqueConstraint()`, and `.primaryKeyConstraint()`.
+ *
+ * @example
+ * ```typescript
+ * ddl.createTable('public', 'users')
+ *   .column('id', 'serial', { primaryKey: true })
+ *   .column('name', 'varchar(255)', { notNull: true })
+ *   .column('email', 'varchar(255)', { notNull: true, unique: true })
+ *   .check('name_length', { column: 'name', op: '>', value: 0 })
+ *   .uniqueConstraint('users_name_email_unique', ['name', 'email']);
+ * ```
+ */
+declare class CreateTableBuilder extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  readonly type: "createTable";
+  private columns;
+  private checks;
+  private _uniqueConstraints;
+  private _primaryKeyConstraint?;
+  /**
+   * @param schema - The PostgreSQL schema to create the table in.
+   * @param name - The table name.
+   */
+  constructor(schema: string, name: string);
+  /**
+   * Add a column to the table.
+   *
+   * @param colName - Column name.
+   * @param type - SQL type (e.g. `"varchar(255)"`, `"integer"`, `"serial"`).
+   * @param options - Column options (constraints, default, references, etc.).
+   * @returns `this` for chaining.
+   */
+  column(colName: string, type: string, options?: ColumnOptions): this;
+  /**
+   * Add a CHECK constraint to the table.
+   *
+   * @param chkName - Constraint name.
+   * @param expr - The check expression.
+   * @returns `this` for chaining.
+   */
+  check(chkName: string, expr: SnapshotCheckExpr): this;
+  /**
+   * Add a table-level UNIQUE constraint spanning one or more columns.
+   *
+   * @param ucName - Constraint name.
+   * @param columns - Column names that form the unique key.
+   * @returns `this` for chaining.
+   */
+  uniqueConstraint(ucName: string, columns: string[]): this;
+  /**
+   * Add a composite PRIMARY KEY constraint.
+   *
+   * @param pkName - Constraint name.
+   * @param columns - Column names that form the primary key.
+   * @returns `this` for chaining.
+   */
+  primaryKeyConstraint(pkName: string, columns: string[]): this;
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that drops an existing table.
+ *
+ * Generates: `DROP TABLE "schema"."name";`
+ *
+ * @example
+ * ```typescript
+ * ddl.dropTable('public', 'users');
+ * // DROP TABLE "public"."users";
+ * ```
+ */
+declare class DropTableStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  readonly type: "dropTable";
+  /**
+   * @param schema - The schema of the table.
+   * @param name - The table name to drop.
+   */
+  constructor(schema: string, name: string);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that renames an existing table.
+ *
+ * Generates: `ALTER TABLE "schema"."oldName" RENAME TO "newName";`
+ *
+ * @example
+ * ```typescript
+ * ddl.renameTable('public', 'users', 'accounts');
+ * // ALTER TABLE "public"."users" RENAME TO "accounts";
+ * ```
+ */
+declare class RenameTableStatement extends DDLStatement {
+  private readonly schema;
+  private readonly oldName;
+  private readonly newName;
+  readonly type: "renameTable";
+  /**
+   * @param schema - The schema of the table.
+   * @param oldName - The current table name.
+   * @param newName - The new table name.
+   */
+  constructor(schema: string, oldName: string, newName: string);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * Chainable builder that constructs `ALTER TABLE` DDL statements.
+ *
+ * Supports adding/dropping columns, changing types, toggling constraints,
+ * and managing defaults. Each chained method appends an action that produces
+ * a separate `ALTER TABLE ... ;` SQL statement when {@link toSQL} is called.
+ *
+ * Use {@link ddl.alterTable} to obtain an instance.
+ *
+ * @example
+ * ```typescript
+ * ddl.alterTable('public', 'users')
+ *   .addColumn('age', 'integer', { notNull: true, default: '0' })
+ *   .dropColumn('legacy_field')
+ *   .setNotNull('email')
+ *   .addUniqueConstraint('users_email_unique', ['email']);
+ * ```
+ */
+declare class AlterTableBuilder extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  readonly type: "alterTable";
+  private actions;
+  /**
+   * @param schema - The schema of the table to alter.
+   * @param name - The table name.
+   */
+  constructor(schema: string, name: string);
+  /**
+   * Add a new column to the table.
+   *
+   * @param name - Column name.
+   * @param type - SQL type (e.g. `"varchar(255)"`).
+   * @param options - Column constraints and options.
+   * @returns `this` for chaining.
+   */
+  addColumn(name: string, type: string, options?: ColumnOptions): this;
+  /**
+   * Drop a column from the table.
+   *
+   * @param name - The column name to drop.
+   * @returns `this` for chaining.
+   */
+  dropColumn(name: string): this;
+  /**
+   * Rename a column.
+   *
+   * @param oldName - The current column name.
+   * @param newName - The new column name.
+   * @returns `this` for chaining.
+   */
+  renameColumn(oldName: string, newName: string): this;
+  /**
+   * Change the type of an existing column.
+   *
+   * @param name - The column name.
+   * @param newType - The new SQL type.
+   * @returns `this` for chaining.
+   */
+  alterColumnType(name: string, newType: string): this;
+  /**
+   * Add a column-level UNIQUE constraint.
+   *
+   * @param column - The column name.
+   * @returns `this` for chaining.
+   */
+  addUnique(column: string): this;
+  /**
+   * Drop a named constraint (UNIQUE, CHECK, or PRIMARY KEY).
+   *
+   * @param name - The constraint name.
+   * @returns `this` for chaining.
+   */
+  dropConstraint(name: string): this;
+  /**
+   * Set `NOT NULL` on a column.
+   *
+   * @param column - The column name.
+   * @returns `this` for chaining.
+   */
+  setNotNull(column: string): this;
+  /**
+   * Drop `NOT NULL` from a column, making it nullable.
+   *
+   * @param column - The column name.
+   * @returns `this` for chaining.
+   */
+  dropNotNull(column: string): this;
+  /**
+   * Set or change the DEFAULT value for a column.
+   *
+   * @param column - The column name.
+   * @param defaultValue - The new default value as a raw SQL expression.
+   * @returns `this` for chaining.
+   */
+  setDefault(column: string, defaultValue: string): this;
+  /**
+   * Drop the DEFAULT value from a column.
+   *
+   * @param column - The column name.
+   * @returns `this` for chaining.
+   */
+  dropDefault(column: string): this;
+  /**
+   * Add a CHECK constraint to the table.
+   *
+   * @param name - Constraint name.
+   * @param expr - The check expression.
+   * @returns `this` for chaining.
+   */
+  addCheck(name: string, expr: SnapshotCheckExpr): this;
+  /**
+   * Add a table-level UNIQUE constraint spanning one or more columns.
+   *
+   * @param name - Constraint name.
+   * @param columns - Column names that form the unique key.
+   * @returns `this` for chaining.
+   */
+  addUniqueConstraint(name: string, columns: string[]): this;
+  /**
+   * Add a composite PRIMARY KEY constraint.
+   *
+   * @param name - Constraint name.
+   * @param columns - Column names that form the primary key.
+   * @returns `this` for chaining.
+   */
+  addPrimaryKeyConstraint(name: string, columns: string[]): this;
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * Chainable builder that constructs a `CREATE INDEX` DDL statement.
+ *
+ * Use {@link ddl.createIndex} to obtain an instance, then chain `.on()`,
+ * and optionally `.using()` and `.unique()`.
+ *
+ * @example
+ * ```typescript
+ * ddl.createIndex('idx_users_email')
+ *   .on('public', 'users', ['email'])
+ *   .using('btree')
+ *   .unique();
+ * // CREATE UNIQUE INDEX idx_users_email ON "public"."users" USING btree ("email");
+ * ```
+ */
+declare class CreateIndexBuilder extends DDLStatement {
+  private readonly indexName;
+  readonly type: "createIndex";
+  private tableSchema;
+  private tableName;
+  private indexType;
+  private indexColumns;
+  private isUnique;
+  private isConcurrent;
+  /**
+   * @param indexName - The name of the index to create.
+   */
+  constructor(indexName: string);
+  /**
+   * Build the index concurrently, without locking writes on the table.
+   *
+   * Generates: `CREATE INDEX CONCURRENTLY ...`
+   *
+   * @remarks
+   * Concurrent index creation cannot run inside a transaction.
+   * Set `transaction: false` in your migration options when using this.
+   *
+   * @returns `this` for chaining.
+   */
+  concurrently(): this;
+  /**
+   * Specify the table and columns this index is created on.
+   *
+   * @param schema - The table's schema.
+   * @param table - The table name.
+   * @param columns - Optional array of column names to index.
+   * @returns `this` for chaining.
+   */
+  on(schema: string, table: string, columns?: string[]): this;
+  /**
+   * Specify the index method.
+   *
+   * @param type - The index type (`"btree"`, `"hash"`, `"gin"`, `"gist"`, etc.).
+   * @param columns - Optional array of column names to index.
+   * @returns `this` for chaining.
+   */
+  using(type: IndexType, columns?: string[]): this;
+  /**
+   * Make this a unique index.
+   *
+   * @returns `this` for chaining.
+   */
+  unique(): this;
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement builder that drops an existing index.
+ *
+ * Generates: `DROP INDEX [CONCURRENTLY] <name>;`
+ *
+ * @example
+ * ```typescript
+ * ddl.dropIndex('idx_users_email');
+ * // DROP INDEX idx_users_email;
+ *
+ * ddl.dropIndex('idx_users_email').concurrently();
+ * // DROP INDEX CONCURRENTLY idx_users_email;
+ * ```
+ */
+declare class DropIndexStatement extends DDLStatement {
+  private readonly indexName;
+  readonly type: "dropIndex";
+  private isConcurrent;
+  /**
+   * @param indexName - The name of the index to drop.
+   */
+  constructor(indexName: string);
+  /**
+   * Drop the index concurrently, without locking writes on the table.
+   *
+   * Generates: `DROP INDEX CONCURRENTLY ...`
+   *
+   * @remarks
+   * Concurrent index drops cannot run inside a transaction.
+   * Set `transaction: false` in your migration options when using this.
+   *
+   * @returns `this` for chaining.
+   */
+  concurrently(): this;
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * The main DDL builder entry point.
+ *
+ * Provides factory methods for all supported DDL operations.
+ * Import from `durcno/migration` and use in migration files.
+ *
+ * @example
+ * ```typescript
+ * import { ddl, type DDLStatement } from 'durcno/migration';
+ *
+ * export const statements: DDLStatement[] = [
+ *   ddl.createEnum('public', 'user_type', ['admin', 'user']),
+ *   ddl.createTable('public', 'users')
+ *     .column('id', 'serial', { primaryKey: true })
+ *     .column('name', 'varchar(255)', { notNull: true }),
+ * ];
+ * ```
+ */
+declare const ddl: {
+  /**
+   * Create a new schema.
+   *
+   * @param name - The schema name.
+   * @returns A {@link CreateSchemaStatement}.
+   */
+  createSchema(name: string): CreateSchemaStatement;
+  /**
+   * Drop a schema.
+   *
+   * @param name - The schema name.
+   * @returns A {@link DropSchemaStatement}.
+   */
+  dropSchema(name: string): DropSchemaStatement;
+  /**
+   * Create a new enum type.
+   *
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name.
+   * @param values - Ordered list of allowed values.
+   * @returns A {@link CreateEnumStatement}.
+   */
+  createEnum(schema: string, name: string, values: string[]): CreateEnumStatement;
+  /**
+   * Add a value to an existing enum.
+   *
+   * @remarks
+   * PostgreSQL does not support removing enum values.
+   *
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name.
+   * @param value - The new value to add.
+   * @param position - Optional positioning: `{ after: 'val' }` or `{ before: 'val' }`.
+   * @returns An {@link AlterEnumAddValueStatement}.
+   */
+  alterEnumAddValue(schema: string, name: string, value: string, position?: {
+    after?: string;
+    before?: string;
+  }): AlterEnumAddValueStatement;
+  /**
+   * Drop an enum type.
+   *
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name.
+   * @returns A {@link DropEnumStatement}.
+   */
+  dropEnum(schema: string, name: string): DropEnumStatement;
+  /**
+   * Create a new sequence.
+   *
+   * @param schema - The schema the sequence belongs to.
+   * @param name - The sequence name.
+   * @param options - Optional sequence configuration.
+   * @returns A {@link CreateSequenceStatement}.
+   */
+  createSequence(schema: string, name: string, options?: SequenceOptions): CreateSequenceStatement;
+  /**
+   * Drop a sequence.
+   *
+   * @param schema - The schema the sequence belongs to.
+   * @param name - The sequence name.
+   * @returns A {@link DropSequenceStatement}.
+   */
+  dropSequence(schema: string, name: string): DropSequenceStatement;
+  /**
+   * Create a new table. Returns a chainable {@link CreateTableBuilder}.
+   *
+   * @param schema - The schema to create the table in.
+   * @param name - The table name.
+   * @returns A {@link CreateTableBuilder} for chaining `.column()`, `.check()`, etc.
+   */
+  createTable(schema: string, name: string): CreateTableBuilder;
+  /**
+   * Drop a table.
+   *
+   * @param schema - The schema of the table.
+   * @param name - The table name.
+   * @returns A {@link DropTableStatement}.
+   */
+  dropTable(schema: string, name: string): DropTableStatement;
+  /**
+   * Rename a table.
+   *
+   * @param schema - The schema of the table.
+   * @param oldName - The current table name.
+   * @param newName - The new table name.
+   * @returns A {@link RenameTableStatement}.
+   */
+  renameTable(schema: string, oldName: string, newName: string): RenameTableStatement;
+  /**
+   * Alter an existing table. Returns a chainable {@link AlterTableBuilder}.
+   *
+   * @param schema - The schema of the table.
+   * @param name - The table name.
+   * @returns An {@link AlterTableBuilder} for chaining `.addColumn()`, `.dropColumn()`, etc.
+   */
+  alterTable(schema: string, name: string): AlterTableBuilder;
+  /**
+   * Create an index. Returns a chainable {@link CreateIndexBuilder}.
+   *
+   * @param name - The index name.
+   * @returns A {@link CreateIndexBuilder} for chaining `.on()`, `.using()`, `.unique()`.
+   *
+   * @example
+   * ```typescript
+   * ddl.createIndex('idx_users_email')
+   *   .on('public', 'users', ['email'])
+   *   .using('btree')
+   *   .unique();
+   * ```
+   */
+  createIndex(name: string): CreateIndexBuilder;
+  /**
+   * Drop an index.
+   *
+   * @param name - The index name.
+   * @returns A {@link DropIndexStatement}.
+   */
+  dropIndex(name: string): DropIndexStatement;
+  /**
+   * Create a custom SQL statement. Preserved during migration regeneration.
+   *
+   * @param sql - The raw SQL string.
+   * @returns A {@link CustomStatement}.
+   */
+  custom(sql: string): CustomStatement;
+};
+//#endregion
+export { ddl };