Documentation
    Preparing search index...

    Interface InitOptions<M>

    Options passed to Model.init

    interface InitOptions<M extends Model = Model> {
        charset?: string;
        collate?: string;
        comment?: string;
        createdAt?: string | boolean;
        defaultScope?: FindOptions<Attributes<M>>;
        deletedAt?: string | boolean;
        engine?: string;
        freezeTableName?: boolean;
        hasTrigger?: boolean;
        hooks?: {
            _UNSTABLE_afterBulkDestroy?: AllowArray<
                | (
                    (
                        options: DestroyOptions<Attributes<M>>,
                        deletedCount: number,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        options: DestroyOptions<Attributes<M>>,
                        deletedCount: number,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            _UNSTABLE_beforeBulkDestroy?: AllowArray<
                | ((options: DestroyOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: DestroyOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterAssociate?: AllowArray<
                | (
                    (
                        data: AfterAssociateEventData,
                        options: AssociationOptions<any>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        data: AfterAssociateEventData,
                        options: AssociationOptions<any>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterBulkCreate?: AllowArray<
                | (
                    (
                        instances: readonly M[],
                        options: BulkCreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instances: readonly M[],
                        options: BulkCreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterBulkDestroy?: AllowArray<
                | ((options: DestroyOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: DestroyOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterBulkRestore?: AllowArray<
                | ((options: RestoreOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: RestoreOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterBulkUpdate?: AllowArray<
                | ((options: UpdateOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: UpdateOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterCreate?: AllowArray<
                | (
                    (
                        attributes: M,
                        options: CreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        attributes: M,
                        options: CreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterDefinitionRefresh?: AllowArray<
                (() => void)
                | { callback: () => void; name: string | symbol },
            >;
            afterDestroy?: AllowArray<
                | ((instance: M, options: InstanceDestroyOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instance: M,
                        options: InstanceDestroyOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterDestroyMany?: AllowArray<
                | (
                    (
                        instances: readonly M[],
                        options: DestroyManyOptions,
                        deletedCount: number,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instances: readonly M[],
                        options: DestroyManyOptions,
                        deletedCount: number,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterFind?: AllowArray<
                | (
                    (
                        instancesOrInstance: M | readonly M[] | null,
                        options: FindOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instancesOrInstance: M | readonly M[] | null,
                        options: FindOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterRestore?: AllowArray<
                | ((instance: M, options: InstanceRestoreOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instance: M,
                        options: InstanceRestoreOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterSave?: AllowArray<
                | (
                    (
                        instance: M,
                        options:
                            | CreateOptions<Attributes<M>>
                            | InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instance: M,
                        options:
                            | CreateOptions<Attributes<M>>
                            | InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterSync?: AllowArray<
                | ((options: SyncOptions) => AsyncHookReturn)
                | {
                    callback: (options: SyncOptions) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterUpdate?: AllowArray<
                | (
                    (
                        instance: M,
                        options: InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instance: M,
                        options: InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterUpsert?: AllowArray<
                | (
                    (
                        attributes: [M, boolean | null],
                        options: UpsertOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        attributes: [M, boolean | null],
                        options: UpsertOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            afterValidate?: AllowArray<
                | ((instance: M, options: ValidationOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instance: M,
                        options: ValidationOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeAssociate?: AllowArray<
                | (
                    (
                        data: BeforeAssociateEventData,
                        options: AssociationOptions<any>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        data: BeforeAssociateEventData,
                        options: AssociationOptions<any>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeBulkCreate?: AllowArray<
                | (
                    (
                        instances: M[],
                        options: BulkCreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instances: M[],
                        options: BulkCreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeBulkDestroy?: AllowArray<
                | ((options: DestroyOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: DestroyOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeBulkRestore?: AllowArray<
                | ((options: RestoreOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: RestoreOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeBulkUpdate?: AllowArray<
                | ((options: UpdateOptions<Attributes<M>>) => AsyncHookReturn)
                | {
                    callback: (options: UpdateOptions<Attributes<M>>) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeCount?: AllowArray<
                | (
                    (options: WritableDeep<CountOptions<TAttributes>>) => AsyncHookReturn
                )
                | {
                    callback: (
                        options: WritableDeep<CountOptions<TAttributes>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeCreate?: AllowArray<
                | (
                    (
                        attributes: M,
                        options: CreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        attributes: M,
                        options: CreateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeDefinitionRefresh?: AllowArray<
                (() => void)
                | { callback: () => void; name: string | symbol },
            >;
            beforeDestroy?: AllowArray<
                | ((instance: M, options: InstanceDestroyOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instance: M,
                        options: InstanceDestroyOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeDestroyMany?: AllowArray<
                | ((instances: M[], options: DestroyManyOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instances: M[],
                        options: DestroyManyOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeFind?: AllowArray<
                | (
                    (options: WritableDeep<FindOptions<TAttributes>>) => AsyncHookReturn
                )
                | {
                    callback: (
                        options: WritableDeep<FindOptions<TAttributes>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeFindAfterExpandIncludeAll?: AllowArray<
                | (
                    (options: WritableDeep<FindOptions<TAttributes>>) => AsyncHookReturn
                )
                | {
                    callback: (
                        options: WritableDeep<FindOptions<TAttributes>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeFindAfterOptions?: AllowArray<
                | (
                    (options: WritableDeep<FindOptions<TAttributes>>) => AsyncHookReturn
                )
                | {
                    callback: (
                        options: WritableDeep<FindOptions<TAttributes>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeRestore?: AllowArray<
                | ((instance: M, options: InstanceRestoreOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instance: M,
                        options: InstanceRestoreOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeSave?: AllowArray<
                | (
                    (
                        instance: M,
                        options:
                            | CreateOptions<Attributes<M>>
                            | InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instance: M,
                        options:
                            | CreateOptions<Attributes<M>>
                            | InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeSync?: AllowArray<
                | ((options: SyncOptions) => AsyncHookReturn)
                | {
                    callback: (options: SyncOptions) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeUpdate?: AllowArray<
                | (
                    (
                        instance: M,
                        options: InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instance: M,
                        options: InstanceUpdateOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeUpsert?: AllowArray<
                | (
                    (
                        attributes: M,
                        options: UpsertOptions<Attributes<M>>,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        attributes: M,
                        options: UpsertOptions<Attributes<M>>,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            beforeValidate?: AllowArray<
                | ((instance: M, options: ValidationOptions) => AsyncHookReturn)
                | {
                    callback: (
                        instance: M,
                        options: ValidationOptions,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
            validationFailed?: AllowArray<
                | (
                    (
                        instance: M,
                        options: ValidationOptions,
                        error: unknown,
                    ) => AsyncHookReturn
                )
                | {
                    callback: (
                        instance: M,
                        options: ValidationOptions,
                        error: unknown,
                    ) => AsyncHookReturn;
                    name: string | symbol;
                },
            >;
        };
        indexes?: readonly IndexOptions[];
        initialAutoIncrement?: string;
        modelName?: string;
        name?: ModelNameOptions;
        noPrimaryKey?: boolean;
        omitNull?: boolean;
        paranoid?: boolean;
        schema?: string;
        schemaDelimiter?: string;
        scopes?: ModelScopeOptions<Attributes<M>>;
        sequelize: Sequelize;
        tableName?: string;
        timestamps?: boolean;
        underscored?: boolean;
        updatedAt?: string | boolean;
        validate?: {
            [name: string]: (
                this: Omit<
                    M["_creationAttributes"],
                    NullishPropertiesOf<M["_creationAttributes"]>,
                > & Partial<
                    Pick<
                        M["_creationAttributes"],
                        NullishPropertiesOf<M["_creationAttributes"]>,
                    >,
                > & ExtractMethods<M>,
                callback?: (err: unknown) => void,
            ) => void;
        };
        version?: string
        | boolean;
    }

    Type Parameters

    Hierarchy (View Summary)

    Index
    charset? collate? comment? createdAt? defaultScope? deletedAt? engine? freezeTableName? hasTrigger? hooks? indexes? initialAutoIncrement? modelName? name? noPrimaryKey? omitNull? paranoid? schema? schemaDelimiter? scopes? sequelize tableName? timestamps? underscored? updatedAt? validate? version?
    charset?: string

    The charset to use for the model

    collate?: string

    The collation for model's table

    comment?: string

    A comment for the table.

    MySQL, PG only.

    createdAt?: string | boolean

    Override the name of the createdAt attribute if a string is provided, or disable it if false. ModelOptions.timestamps must be true.

    Not affected by underscored setting.

    defaultScope?: FindOptions<Attributes<M>>

    Define the default search scope to use for this model. Scopes have the same form as the options passed to find / findAll.

    See https://sequelize.org/docs/v7/other-topics/scopes/ to learn more about scopes.

    deletedAt?: string | boolean

    Override the name of the deletedAt attribute if a string is provided, or disable it if false. ModelOptions.timestamps must be true. ModelOptions.paranoid must be true.

    Not affected by underscored setting.

    engine?: string

    The name of the database storage engine to use (e.g. MyISAM, InnoDB).

    MySQL, MariaDB only.

    freezeTableName?: boolean

    If true, sequelize will use the name of the Model as-is as the name of the SQL table. If false, the name of the table will be pluralised (and snake_cased if ModelOptions.underscored is true).

    This option has no effect if ModelOptions.tableName is set.

    false
    hasTrigger?: boolean

    Indicates if the model's table has a trigger associated with it.

    false
    hooks?: {
        _UNSTABLE_afterBulkDestroy?: AllowArray<
            | (
                (
                    options: DestroyOptions<Attributes<M>>,
                    deletedCount: number,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    options: DestroyOptions<Attributes<M>>,
                    deletedCount: number,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        _UNSTABLE_beforeBulkDestroy?: AllowArray<
            | ((options: DestroyOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: DestroyOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterAssociate?: AllowArray<
            | (
                (
                    data: AfterAssociateEventData,
                    options: AssociationOptions<any>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    data: AfterAssociateEventData,
                    options: AssociationOptions<any>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterBulkCreate?: AllowArray<
            | (
                (
                    instances: readonly M[],
                    options: BulkCreateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instances: readonly M[],
                    options: BulkCreateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterBulkDestroy?: AllowArray<
            | ((options: DestroyOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: DestroyOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterBulkRestore?: AllowArray<
            | ((options: RestoreOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: RestoreOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterBulkUpdate?: AllowArray<
            | ((options: UpdateOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: UpdateOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterCreate?: AllowArray<
            | (
                (
                    attributes: M,
                    options: CreateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    attributes: M,
                    options: CreateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterDefinitionRefresh?: AllowArray<
            (() => void)
            | { callback: () => void; name: string | symbol },
        >;
        afterDestroy?: AllowArray<
            | ((instance: M, options: InstanceDestroyOptions) => AsyncHookReturn)
            | {
                callback: (
                    instance: M,
                    options: InstanceDestroyOptions,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterDestroyMany?: AllowArray<
            | (
                (
                    instances: readonly M[],
                    options: DestroyManyOptions,
                    deletedCount: number,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instances: readonly M[],
                    options: DestroyManyOptions,
                    deletedCount: number,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterFind?: AllowArray<
            | (
                (
                    instancesOrInstance: M | readonly M[] | null,
                    options: FindOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instancesOrInstance: M | readonly M[] | null,
                    options: FindOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterRestore?: AllowArray<
            | ((instance: M, options: InstanceRestoreOptions) => AsyncHookReturn)
            | {
                callback: (
                    instance: M,
                    options: InstanceRestoreOptions,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterSave?: AllowArray<
            | (
                (
                    instance: M,
                    options:
                        | CreateOptions<Attributes<M>>
                        | InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instance: M,
                    options:
                        | CreateOptions<Attributes<M>>
                        | InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterSync?: AllowArray<
            | ((options: SyncOptions) => AsyncHookReturn)
            | {
                callback: (options: SyncOptions) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterUpdate?: AllowArray<
            | (
                (
                    instance: M,
                    options: InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instance: M,
                    options: InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterUpsert?: AllowArray<
            | (
                (
                    attributes: [M, boolean | null],
                    options: UpsertOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    attributes: [M, boolean | null],
                    options: UpsertOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        afterValidate?: AllowArray<
            | ((instance: M, options: ValidationOptions) => AsyncHookReturn)
            | {
                callback: (instance: M, options: ValidationOptions) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeAssociate?: AllowArray<
            | (
                (
                    data: BeforeAssociateEventData,
                    options: AssociationOptions<any>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    data: BeforeAssociateEventData,
                    options: AssociationOptions<any>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeBulkCreate?: AllowArray<
            | (
                (
                    instances: M[],
                    options: BulkCreateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instances: M[],
                    options: BulkCreateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeBulkDestroy?: AllowArray<
            | ((options: DestroyOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: DestroyOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeBulkRestore?: AllowArray<
            | ((options: RestoreOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: RestoreOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeBulkUpdate?: AllowArray<
            | ((options: UpdateOptions<Attributes<M>>) => AsyncHookReturn)
            | {
                callback: (options: UpdateOptions<Attributes<M>>) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeCount?: AllowArray<
            | (
                (options: WritableDeep<CountOptions<TAttributes>>) => AsyncHookReturn
            )
            | {
                callback: (
                    options: WritableDeep<CountOptions<TAttributes>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeCreate?: AllowArray<
            | (
                (
                    attributes: M,
                    options: CreateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    attributes: M,
                    options: CreateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeDefinitionRefresh?: AllowArray<
            (() => void)
            | { callback: () => void; name: string | symbol },
        >;
        beforeDestroy?: AllowArray<
            | ((instance: M, options: InstanceDestroyOptions) => AsyncHookReturn)
            | {
                callback: (
                    instance: M,
                    options: InstanceDestroyOptions,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeDestroyMany?: AllowArray<
            | ((instances: M[], options: DestroyManyOptions) => AsyncHookReturn)
            | {
                callback: (
                    instances: M[],
                    options: DestroyManyOptions,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeFind?: AllowArray<
            | (
                (options: WritableDeep<FindOptions<TAttributes>>) => AsyncHookReturn
            )
            | {
                callback: (
                    options: WritableDeep<FindOptions<TAttributes>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeFindAfterExpandIncludeAll?: AllowArray<
            | (
                (options: WritableDeep<FindOptions<TAttributes>>) => AsyncHookReturn
            )
            | {
                callback: (
                    options: WritableDeep<FindOptions<TAttributes>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeFindAfterOptions?: AllowArray<
            | (
                (options: WritableDeep<FindOptions<TAttributes>>) => AsyncHookReturn
            )
            | {
                callback: (
                    options: WritableDeep<FindOptions<TAttributes>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeRestore?: AllowArray<
            | ((instance: M, options: InstanceRestoreOptions) => AsyncHookReturn)
            | {
                callback: (
                    instance: M,
                    options: InstanceRestoreOptions,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeSave?: AllowArray<
            | (
                (
                    instance: M,
                    options:
                        | CreateOptions<Attributes<M>>
                        | InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instance: M,
                    options:
                        | CreateOptions<Attributes<M>>
                        | InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeSync?: AllowArray<
            | ((options: SyncOptions) => AsyncHookReturn)
            | {
                callback: (options: SyncOptions) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeUpdate?: AllowArray<
            | (
                (
                    instance: M,
                    options: InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instance: M,
                    options: InstanceUpdateOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeUpsert?: AllowArray<
            | (
                (
                    attributes: M,
                    options: UpsertOptions<Attributes<M>>,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    attributes: M,
                    options: UpsertOptions<Attributes<M>>,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        beforeValidate?: AllowArray<
            | ((instance: M, options: ValidationOptions) => AsyncHookReturn)
            | {
                callback: (instance: M, options: ValidationOptions) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
        validationFailed?: AllowArray<
            | (
                (
                    instance: M,
                    options: ValidationOptions,
                    error: unknown,
                ) => AsyncHookReturn
            )
            | {
                callback: (
                    instance: M,
                    options: ValidationOptions,
                    error: unknown,
                ) => AsyncHookReturn;
                name: string | symbol;
            },
        >;
    }

    Add hooks to the model. Hooks will be called before and after certain operations.

    This can also be done through Model.addHook, or the individual hook methods such as Model.afterBulkCreate. Each property can either be a function, or an array of functions.

    https://sequelize.org/docs/v7/other-topics/hooks/

    indexes?: readonly IndexOptions[]

    Indexes for the provided database table

    initialAutoIncrement?: string

    Set the initial AUTO_INCREMENT value for the table in MySQL.

    modelName?: string

    The name of the model.

    If not set, the name of the class will be used instead. You should specify this option if you are going to minify your code in a way that may mangle the class name.

    Not inherited.

    name?: ModelNameOptions

    An object with two attributes, singular and plural, which are used when this model is associated to others.

    Not inherited.

    noPrimaryKey?: boolean

    Sequelize will automatically add a primary key called id if no primary key has been added manually.

    Set to false to disable adding that primary key.

    false
    omitNull?: boolean

    Don't persist null values. This means that all columns with null values will not be saved.

    false
    paranoid?: boolean

    If true, calling Model.destroy will not delete the model, but will instead set a deletedAt timestamp.

    This options requires ModelOptions.timestamps to be true. The deletedAt column can be customized through ModelOptions.deletedAt.

    false
    schema?: string

    The database schema in which this table will be located.

    schemaDelimiter?: string
    scopes?: ModelScopeOptions<Attributes<M>>

    More scopes, defined in the same way as ModelOptions.defaultScope above. See Model.scope for more information about how scopes are defined, and what you can do with them.

    See https://sequelize.org/docs/v7/other-topics/scopes/ to learn more about scopes.

    sequelize: Sequelize

    The sequelize connection. Required ATM.

    tableName?: string

    The name of the table in SQL.

    The ModelOptions.modelName, pluralized, unless freezeTableName is true, in which case it uses model name verbatim.

    Not inherited.

    timestamps?: boolean

    Adds createdAt and updatedAt timestamps to the model.

    true
    underscored?: boolean

    If true, Sequelize will snake_case the name of columns that do not have an explicit value set (using AttributeOptions.field). The name of the table will also be snake_cased, unless ModelOptions.tableName is set, or ModelOptions.freezeTableName is true.

    false
    updatedAt?: string | boolean

    Override the name of the updatedAt attribute if a string is provided, or disable it if false. ModelOptions.timestamps must be true.

    Not affected by underscored setting.

    validate?: {
        [name: string]: (
            this: Omit<
                M["_creationAttributes"],
                NullishPropertiesOf<M["_creationAttributes"]>,
            > & Partial<
                Pick<
                    M["_creationAttributes"],
                    NullishPropertiesOf<M["_creationAttributes"]>,
                >,
            > & ExtractMethods<M>,
            callback?: (err: unknown) => void,
        ) => void;
    }

    An object of model wide validations. Validations have access to all model values via this. If the validator function takes an argument, it is assumed to be async, and is called with a callback that accepts an optional error.

    Type Declaration

    • [name: string]: (
          this: Omit<
              M["_creationAttributes"],
              NullishPropertiesOf<M["_creationAttributes"]>,
          > & Partial<
              Pick<
                  M["_creationAttributes"],
                  NullishPropertiesOf<M["_creationAttributes"]>,
              >,
          > & ExtractMethods<M>,
          callback?: (err: unknown) => void,
      ) => void

      Custom validation functions run on all instances of the model.

    version?: string | boolean

    Enable optimistic locking. When enabled, sequelize will add a version count attribute to the model and throw an OptimisticLockingError error when stale instances are saved.

    • If string: Uses the named attribute.
    • If boolean: Uses version.
    false

    Settings
    Member Visibility

    On This Page
    Properties