import type { Branch, BranchCreateRequest, BranchSchemaCompareResponse, BranchUpdateRequest, Endpoint, ListProjectBranchesData } from "../../client/types.gen.js";
import type { CallOptions, RequestContext } from "../context.js";
import { type Paginated } from "../paginate.js";
import { type Outcome } from "../result.js";
type ListQuery = Omit<NonNullable<ListProjectBranchesData["query"]>, "cursor">;
type BranchFields = NonNullable<BranchCreateRequest["branch"]>;
type UpdateInput = BranchUpdateRequest["branch"];
export interface ComputeSettings {
    minCu?: number;
    maxCu?: number;
    suspendTimeoutSeconds?: number;
}
type CreateInputBase = BranchFields & {
    compute?: ComputeSettings;
};
export type CreateInput = (CreateInputBase & {
    noCompute?: false;
}) | (BranchFields & {
    noCompute: true;
    compute?: never;
});
export interface CreateAndConnectInput {
    name?: string;
    /** Parent branch id. Defaults to the project's default branch. */
    parentId?: string;
    compute?: ComputeSettings;
}
/** A branch with its read-write endpoint and a ready-to-use connection string. */
export interface BranchConnection {
    branch: Branch;
    endpoint: Endpoint;
    connectionString: string;
}
export interface ResetFromParentInput {
    /** Required when the branch has children so they can move to the preserved branch. */
    preserveUnderName?: string;
}
export interface CompareSchemaInput {
    databaseName: string;
    baseBranchId?: string;
    lsn?: string;
    timestamp?: string;
    baseLsn?: string;
    baseTimestamp?: string;
}
export type BranchListParams = ListQuery & {
    projectId: string;
};
export interface BranchGetParams {
    projectId: string;
    branchId: string;
}
export type BranchCreateParams = CreateInput & {
    projectId: string;
};
export type BranchUpdateParams = UpdateInput & {
    projectId: string;
    branchId: string;
};
export interface BranchDeleteParams {
    projectId: string;
    branchId: string;
}
export type BranchCreateAndConnectParams = CreateAndConnectInput & {
    projectId: string;
    /** Return a pooled connection string (default `true`). */
    pooled?: boolean;
};
export interface BranchGetDefaultParams {
    projectId: string;
}
export interface BranchSetDefaultParams {
    projectId: string;
    branchId: string;
}
export type BranchResetFromParentParams = ResetFromParentInput & {
    projectId: string;
    branchId: string;
};
export type BranchCompareSchemaParams = CompareSchemaInput & {
    projectId: string;
    branchId: string;
};
export interface BranchFinalizeRestoreParams {
    projectId: string;
    branchId: string;
    name?: string;
}
export declare class Branches<DThrow extends boolean> {
    #private;
    constructor(ctx: RequestContext);
    /** @apiCall GET /projects/{project_id}/branches (cursor-paginated) */
    list(params: BranchListParams): Paginated<Branch, DThrow>;
    list<Throw extends boolean = DThrow>(params: BranchListParams, opts: CallOptions<Throw>): Paginated<Branch, Throw>;
    /** @apiCall GET /projects/{project_id}/branches/{branch_id} */
    get(params: BranchGetParams): Promise<Outcome<Branch, DThrow>>;
    get<Throw extends boolean = DThrow>(params: BranchGetParams, opts: CallOptions<Throw>): Promise<Outcome<Branch, Throw>>;
    /**
     * This method retains its branch-only result even when it provisions compute;
     * use {@link Branches.createAndConnect} or `postgres.connectionString` when a
     * connection string is needed.
     *
     * Readiness polling stays on for `noCompute` branches because a
     * compute-less branch still has provisioning operations.
     */
    create(params: BranchCreateParams): Promise<Outcome<Branch, DThrow>>;
    create<Throw extends boolean = DThrow>(params: BranchCreateParams, opts: CallOptions<Throw>): Promise<Outcome<Branch, Throw>>;
    /** @apiCall PATCH /projects/{project_id}/branches/{branch_id} */
    update(params: BranchUpdateParams): Promise<Outcome<Branch, DThrow>>;
    update<Throw extends boolean = DThrow>(params: BranchUpdateParams, opts: CallOptions<Throw>): Promise<Outcome<Branch, Throw>>;
    /** @apiCall DELETE /projects/{project_id}/branches/{branch_id} */
    delete(params: BranchDeleteParams): Promise<Outcome<void, DThrow>>;
    delete<Throw extends boolean = DThrow>(params: BranchDeleteParams, opts: CallOptions<Throw>): Promise<Outcome<void, Throw>>;
    createAndConnect(params: BranchCreateAndConnectParams): Promise<Outcome<BranchConnection, DThrow>>;
    createAndConnect<Throw extends boolean = DThrow>(params: BranchCreateAndConnectParams, opts: CallOptions<Throw>): Promise<Outcome<BranchConnection, Throw>>;
    /**
     * Resolve the project's default branch (by the `default` flag — not by name).
     * Returns a {@link NeonClientError} when no default branch is found.
     */
    getDefault(params: BranchGetDefaultParams): Promise<Outcome<Branch, DThrow>>;
    getDefault<Throw extends boolean = DThrow>(params: BranchGetDefaultParams, opts: CallOptions<Throw>): Promise<Outcome<Branch, Throw>>;
    /** @apiCall POST /projects/{project_id}/branches/{branch_id}/set_as_default */
    setDefault(params: BranchSetDefaultParams): Promise<Outcome<Branch, DThrow>>;
    setDefault<Throw extends boolean = DThrow>(params: BranchSetDefaultParams, opts: CallOptions<Throw>): Promise<Outcome<Branch, Throw>>;
    /**
     * Uses the parent's current HEAD; use raw `restoreProjectBranch` for an LSN or timestamp.
     *
     * @apiCall GET /projects/{project_id}/branches/{branch_id}
     * @apiCall POST /projects/{project_id}/branches/{branch_id}/restore
     */
    resetFromParent(params: BranchResetFromParentParams): Promise<Outcome<Branch, DThrow>>;
    resetFromParent<Throw extends boolean = DThrow>(params: BranchResetFromParentParams, opts: CallOptions<Throw>): Promise<Outcome<Branch, Throw>>;
    /**
     * Returns a unified SQL diff; omitting `baseBranchId` uses the parent branch.
     *
     * @apiCall GET /projects/{project_id}/branches/{branch_id}/compare_schema
     */
    compareSchema(params: BranchCompareSchemaParams): Promise<Outcome<BranchSchemaCompareResponse, DThrow>>;
    compareSchema<Throw extends boolean = DThrow>(params: BranchCompareSchemaParams, opts: CallOptions<Throw>): Promise<Outcome<BranchSchemaCompareResponse, Throw>>;
    /**
     * Complete (commit) a restore previously started with `snapshots.restore({ finalize: false })`:
     * moves computes onto the restored branch and renames the replaced one. This is **only**
     * the second step — it does not restore anything itself.
     *
     * @apiCall POST /projects/{project_id}/branches/{branch_id}/restore/finalize
     */
    finalizeRestore(params: BranchFinalizeRestoreParams): Promise<Outcome<void, DThrow>>;
    finalizeRestore<Throw extends boolean = DThrow>(params: BranchFinalizeRestoreParams, opts: CallOptions<Throw>): Promise<Outcome<void, Throw>>;
}
export {};
//# sourceMappingURL=branches.d.ts.map