import * as Provider from "../../Provider.ts";
import { Resource } from "../../Resource.ts";
import type { Providers } from "../Providers.ts";
export interface DBParameterGroupProps {
    /**
     * Name of the parameter group. If omitted, Alchemy generates one.
     */
    dbParameterGroupName?: string;
    /**
     * Parameter group family, for example `aurora-postgresql16`.
     */
    family: string;
    /**
     * Human-readable description.
     */
    description?: string;
    /**
     * Instance parameter overrides, e.g. `{ time_zone: "Australia/Sydney" }`.
     *
     * When set, this map is the group's entire user-owned surface: entries are
     * written, and any parameter RDS reports as user-set but absent here is
     * reset to its engine default. `{}` therefore resets every override, while
     * OMITTING the prop leaves parameters alone entirely — which is what makes
     * it safe to adopt a group that was tuned elsewhere.
     *
     * Values must be in the form RDS reports back (it canonicalises some — a
     * boolean set as `ON` reads back as `1`), or the two never compare equal
     * and every deploy re-issues the modify.
     *
     * Static parameters are applied with `pending-reboot`, dynamic parameters
     * with `immediate`.
     */
    parameters?: Record<string, string>;
    /**
     * User-defined tags.
     */
    tags?: Record<string, string>;
}
export interface DBParameterGroup extends Resource<"AWS.RDS.DBParameterGroup", DBParameterGroupProps, {
    /**
     * Name of the parameter group.
     */
    dbParameterGroupName: string;
    /**
     * ARN of the parameter group.
     */
    dbParameterGroupArn: string | undefined;
    /**
     * Parameter group family (e.g. `aurora-postgresql16`).
     */
    family: string;
    /**
     * Description of the parameter group.
     */
    description: string | undefined;
    /**
     * The parameter overrides this resource manages; `{}` when `parameters`
     * is omitted and the group's settings are owned elsewhere.
     */
    parameters: Record<string, string>;
    /**
     * Tags on the parameter group.
     */
    tags: Record<string, string>;
}, never, Providers> {
}
/**
 * An RDS DB parameter group — instance-level engine settings, applied to a
 * `DBInstance` (as opposed to the cluster-wide `DBClusterParameterGroup`).
 *
 * Name, family, and description changes force a replacement (RDS has no
 * modify API for these); parameters and tags update in place.
 * ### Creating a Parameter Group
 * **Example:** Parameter Group for Aurora Postgres 16 Instances
 * ```typescript
 * const instanceParams = yield* DBParameterGroup("InstanceParams", {
 *   family: "aurora-postgresql16",
 *   description: "Instance-level settings for the app database",
 * });
 * ```
 *
 * **Example:** Set Engine Parameters
 * ```typescript
 * const params = yield* DBParameterGroup("MysqlParams", {
 *   family: "mysql8.4",
 *   parameters: {
 *     time_zone: "Australia/Sydney",
 *     max_connections: "200",
 *   },
 * });
 * ```
 * Dynamic parameters apply immediately, static ones on the next reboot.
 * Cluster-wide settings belong on `DBClusterParameterGroup` instead — Postgres
 * `timezone`, for example, is a cluster parameter on Aurora.
 *
 * **Example:** Attach to an Instance
 * ```typescript
 * const writer = yield* DBInstance("Writer", {
 *   dbClusterIdentifier: cluster.dbClusterIdentifier,
 *   dbInstanceClass: "db.serverless",
 *   engine: "aurora-postgresql",
 *   dbParameterGroupName: instanceParams.dbParameterGroupName,
 * });
 * ```
 *
 * @resource
 */
export declare const DBParameterGroup: import("../../Resource.ts").ResourceClass<DBParameterGroup>;
export declare const DBParameterGroupProvider: () => import("effect/Layer").Layer<Provider.Provider<DBParameterGroup>, never, import("@distilled.cloud/aws/Credentials").Credentials | import("effect/unstable/http/HttpClient").HttpClient | import("../../Stack.ts").Stack | import("../../Stage.ts").Stage>;
//# sourceMappingURL=DBParameterGroup.d.ts.map