import * as Layer from "effect/Layer";
import { AuthProviders } from "../Auth/AuthProvider.ts";
import { AlchemyProfile } from "../Auth/Profile.ts";
import * as Provider from "../Provider.ts";
import { App } from "./App.ts";
import { Branch } from "./Branch.ts";
import { Bucket } from "./Bucket.ts";
import { BucketAccessKey } from "./BucketAccessKey.ts";
import { PrismaClient } from "./Client.ts";
import { Connection } from "./Connection.ts";
import { Compute } from "./Compute.ts";
import { CustomDomain } from "./CustomDomain.ts";
import { Database } from "./Database.ts";
import { Deployment } from "./Deployment.ts";
import { EnvironmentVariable } from "./EnvironmentVariable.ts";
import { Project } from "./Project.ts";
import { SourceRepository } from "./SourceRepository.ts";
export { PrismaEnvironment } from "./PrismaEnvironment.ts";
declare const Providers_base: Provider.ProviderCollection<Providers, "Prisma">;
export declare class Providers extends Providers_base {
}
export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
/**
 * Build a layer for Prisma Management API operation helpers.
 *
 * Use this when calling helpers like `Prisma.listProjects()` outside an
 * Alchemy stack or test. Inside a stack (or a `test.provider` body) deployed
 * with `Prisma.providers()`, the management client is already in context, so
 * operation helpers work without providing this layer.
 *
 * @example
 * ```typescript
 * const projects = yield* Prisma.listProjects().pipe(
 *   Effect.provide(Prisma.managementApi()),
 * );
 * ```
 */
export declare const managementApi: () => Layer.Layer<AlchemyProfile | AuthProviders | import("../Auth/Credentials.ts").CredentialsStore | PrismaClient | import("./PrismaEnvironment.ts").PrismaEnvironment | import("./Internal/HttpClient.ts").PrismaUploadClient, never, never>;
/**
 * Build a layer that registers all Prisma resource providers, the Prisma
 * auth provider, resolved credentials, and an HTTP client.
 *
 * Every resource is registered with {@link ../Local/ProviderLayer.ts
 * ProviderLayer.dual}: a **live** implementation backed by the Prisma
 * Management API and a **local** implementation used by `alchemy dev`
 * (fabricated `dev:` identifiers; `Prisma.Database` boots a local
 * `@prisma/dev` server). The engine picks the variant per run and per
 * resource:
 *
 * - `alchemy deploy` resolves the live variant; `alchemy dev` resolves the
 *   local variant automatically.
 * - Wrap a resource in `Alchemy.remote(...)` to keep it live even during
 *   `alchemy dev`.
 * - To replace implementations wholesale, construct your own layer instead
 *   of this one: register the {@link Providers} collection and provide your
 *   own per-resource provider layers (compose the exported per-resource
 *   factories like {@link ProjectProvider} with your replacements, and
 *   {@link managementApi} when live operations are needed).
 *
 * @example
 * ```typescript
 * import * as Alchemy from "alchemy";
 * import * as Prisma from "alchemy/Prisma";
 * import * as Effect from "effect/Effect";
 *
 * export default Alchemy.Stack(
 *   "MyStack",
 *   { providers: Prisma.providers(), state: Alchemy.localState() },
 *   Effect.gen(function* () {
 *     const project = yield* Prisma.Project("app", {
 *       name: "app",
 *       region: "us-east-1",
 *     });
 *     return { projectId: project.projectId };
 *   }),
 * );
 * ```
 */
export declare const providers: () => Layer.Layer<AlchemyProfile | import("../Auth/Credentials.ts").CredentialsStore | PrismaClient | import("./Internal/HttpClient.ts").PrismaUploadClient | Provider.Provider<App> | Provider.Provider<Branch> | Provider.Provider<Bucket> | Provider.Provider<BucketAccessKey> | Provider.Provider<Compute> | Provider.Provider<Connection> | Provider.Provider<CustomDomain> | Provider.Provider<Database> | Provider.Provider<Deployment> | Provider.Provider<EnvironmentVariable> | Provider.Provider<Project> | Provider.Provider<SourceRepository> | Providers, never, any>;
//# sourceMappingURL=Providers.d.ts.map