@samebase/alchemy-convex 0.1.0 → 0.3.0

package/lib/index.d.ts

@@ -1,10 +1,511 @@
-export { ACCESS_TOKEN_ENV, Credentials, CredentialsError, fromConfig, fromToken, } from "./Credentials.ts";
-export { DefaultEnvironmentVariable, type DefaultEnvironmentVariableAttributes, type DefaultEnvironmentVariableProps, type DeploymentType, } from "./DefaultEnvironmentVariable.ts";
-export { Deploy, type DeployAttributes, deployArgs, type DeployProps, parseDeployOutput, } from "./Deploy.ts";
-export { DeployKey, type DeployKeyAction, type DeployKeyAttributes, type DeployKeyProps, } from "./DeployKey.ts";
-export { EnvironmentVariable, type EnvironmentVariableAttributes, type EnvironmentVariableProps, } from "./EnvironmentVariable.ts";
-export { ConvexApiError, ManagementApi } from "./ManagementApi.ts";
-export { PreviewDeployKey, type PreviewDeployKeyAttributes, type PreviewDeployKeyProps, } from "./PreviewDeployKey.ts";
-export { type DeploymentRegion, Project, type ProjectAttributes, type ProjectProps, } from "./Project.ts";
-export { Providers, providers } from "./Providers.ts";
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import * as Effect from "effect/Effect";
+import "effect/process/ChildProcessSpawner";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { createDeploymentClient, createManagementClient } from "@convex-dev/platform";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import { CommandExecutor, CommandRunProps } from "alchemy/Command";
+import { MemoOptions } from "alchemy/Command/Memo";
+import { components } from "@convex-dev/platform/managementApi";
+//#region src/Credentials.d.ts
+interface ResolvedCredentials {
+  /** Bearer token accepted by https://api.convex.dev/v1: a team access token, an OAuth token, or the Convex CLI login. */
+  readonly accessToken: Redacted.Redacted<string>;
+  /** Where the token came from, for error messages only. */
+  readonly source: "env" | "explicit" | "convex-cli-login";
+}
+declare const Credentials_base: Context.ServiceClass<Credentials, "@samebase/alchemy-convex/Credentials", Effect.Effect<ResolvedCredentials, never, never>>;
+declare class Credentials extends Credentials_base {}
+/** Environment variable read by {@link fromConfig}. */
+declare const ACCESS_TOKEN_ENV = "CONVEX_ACCESS_TOKEN";
+declare const CredentialsError_base: Schema.Class<CredentialsError, Schema.TaggedStruct<"CredentialsError", {
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class CredentialsError extends CredentialsError_base {}
+/**
+ * Default resolution: `CONVEX_ACCESS_TOKEN` from the stack ConfigProvider
+ * (process env, `.env`, stack secrets), then the Convex CLI login on this
+ * machine. CI sets the variable; a developer who ran `npx convex login` needs
+ * nothing.
+ */
+declare const fromConfig: () => Layer.Layer<Credentials>;
+/** Explicit token, for tests or callers that already hold a value. */
+declare const fromToken: (accessToken: Redacted.Redacted<string>) => Layer.Layer<Credentials>;
+//#endregion
+//#region src/ManagementApi.d.ts
+type ManagementClient = ReturnType<typeof createManagementClient>;
+type DeploymentClient = ReturnType<typeof createDeploymentClient>;
+/** Shape of every openapi-fetch result we consume. */
+interface FetchResult<T> {
+  readonly data?: T;
+  readonly error?: unknown;
+  readonly response: Response;
+}
+declare const ConvexApiError_base: Schema.Class<ConvexApiError, Schema.TaggedStruct<"ConvexApiError", {
+  readonly operation: Schema.String;
+  readonly status: Schema.Number;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * One error for every control-plane and deployment call. Resources branch on
+ * `status` (404 means absent for read and delete), so the class is load
+ * bearing, not decorative.
+ */
+declare class ConvexApiError extends ConvexApiError_base {}
+interface ManagementApiService {
+  /** Run one management call with the resolved credentials. */
+  readonly request: <T>(operation: string, run: (client: ManagementClient) => Promise<FetchResult<T>>) => Effect.Effect<T, ConvexApiError>;
+  /** Run one management call whose success response has no body. */
+  readonly requestVoid: (operation: string, run: (client: ManagementClient) => Promise<FetchResult<unknown>>) => Effect.Effect<void, ConvexApiError>;
+  /** Run one deployment-scoped call authenticated with a deploy key. */
+  readonly deploymentRequest: <T>(operation: string, deploymentUrlOrName: string, deployKey: Redacted.Redacted<string>, run: (client: DeploymentClient) => Promise<FetchResult<T>>) => Effect.Effect<T, ConvexApiError>;
+  /** Team id for a slug or numeric id. */
+  readonly resolveTeamId: (team: string | number) => Effect.Effect<number, ConvexApiError>;
+  /**
+   * True when a deploy key that Convex returned carries the token of the
+   * Management API credential itself. With an OAuth token, create_deploy_key
+   * and create_preview_deploy_key create no new key: they return the OAuth
+   * token with a new prefix, and the part after "|" is the same. A delete of
+   * that key would revoke the credential.
+   */
+  readonly isCredentialToken: (secret: string) => Effect.Effect<boolean>;
+}
+declare const ManagementApi_base: Context.ServiceClass<ManagementApi, "@samebase/alchemy-convex/ManagementApi", ManagementApiService>;
+declare class ManagementApi extends ManagementApi_base {}
+//#endregion
+//#region src/Providers.d.ts
+declare const Providers_base: Provider.ProviderCollection<Providers, "Convex">;
+declare class Providers extends Providers_base {}
+/**
+ * All Convex resource providers. Pass a credentials layer to override the
+ * default lookup (`CONVEX_ACCESS_TOKEN`, then the Convex CLI login).
+ */
+declare const providers: (credentials?: Layer.Layer<Credentials>) => Layer.Layer<Providers, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+//#endregion
+//#region src/Deployment.d.ts
+type DeploymentProps = {
+  /** Numeric project id, such as `project.projectId`. Cannot change. */
+  readonly projectId: number;
+  /** The project's default production deployment. Cannot change. */
+  readonly type: "prod";
+} | {
+  /** Numeric project id, such as `project.projectId`. Cannot change. */
+  readonly projectId: number;
+  /** A dev deployment or a preview deployment that this resource creates. Cannot change. */
+  readonly type: "dev" | "preview";
+  /**
+   * The dev reference, such as `staging`, or the preview name, such as a
+   * pull request or stage name. Unique in the project. Cannot change.
+   */
+  readonly name: string;
+};
+interface DeploymentAttributes {
+  readonly projectId: number;
+  readonly type: DeploymentProps["type"];
+  /** Deployment name, such as `happy-animal-123`. */
+  readonly name: string;
+  /** The reference that Convex lists, such as `production`, `staging`, or `preview/pr-42`. */
+  readonly reference: string;
+  /** The preview name of a preview deployment. Undefined for prod and dev. */
+  readonly previewName: string | undefined;
+  /** Client URL, such as `https://happy-animal-123.convex.cloud`. */
+  readonly url: string;
+  /** HTTP actions URL, such as `https://happy-animal-123.convex.site`. */
+  readonly siteUrl: string;
+}
+type Deployment = Resource<"Convex.Deployment", DeploymentProps, DeploymentAttributes, never, Providers>;
+declare const Deployment: import("alchemy").ResourceClass<Deployment>;
+declare const DeploymentIdentityChange_base: Schema.Class<DeploymentIdentityChange, Schema.TaggedStruct<"DeploymentIdentityChange", {
+  /** Name of the deployment in state, such as `happy-animal-123`. */
+  readonly deployment: Schema.String;
+  readonly field: Schema.Literals<readonly ["projectId", "type", "name"]>;
+  readonly current: Schema.String;
+  readonly requested: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The props name another deployment than the one in state. */
+declare class DeploymentIdentityChange extends DeploymentIdentityChange_base {
+  get message(): string;
+}
+declare const ProductionDeploymentNotFound_base: Schema.Class<ProductionDeploymentNotFound, Schema.TaggedStruct<"ProductionDeploymentNotFound", {
+  readonly projectId: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** The project has no default production deployment for a `prod` resource to take over. */
+declare class ProductionDeploymentNotFound extends ProductionDeploymentNotFound_base {
+  get message(): string;
+}
+declare const AmbiguousDeployment_base: Schema.Class<AmbiguousDeployment, Schema.TaggedStruct<"AmbiguousDeployment", {
+  readonly projectId: Schema.Number;
+  readonly type: Schema.Literals<readonly ["dev", "preview"]>;
+  readonly name: Schema.String;
+  readonly deployments: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** More than one deployment of the project has the name, so the lookup cannot choose one. */
+declare class AmbiguousDeployment extends AmbiguousDeployment_base {
+  get message(): string;
+}
+//#endregion
+//#region src/Code.d.ts
+/** The attributes of a Convex.Deployment that a push needs. Pass the resource itself. */
+type CodeDeployment = Pick<DeploymentAttributes, "name" | "type" | "url" | "previewName">;
+interface CodeProps {
+  /**
+   * The deployment that receives the push: a Convex.Deployment resource, or a
+   * deployment name such as `happy-animal-123`. A preview deploy key needs the
+   * resource. For `env` on a deployment outside US East, pass the resource.
+   */
+  readonly deployment: string | CodeDeployment;
+  /**
+   * A deploy key of `deployment` (Convex.DeployKey), or, for a preview
+   * deployment, a preview deploy key of its project (Convex.PreviewDeployKey).
+   */
+  readonly deployKey: Redacted.Redacted<string>;
+  /** The Convex app directory: the one with `convex/` and the `convex` package installed. */
+  readonly cwd: string;
+  /**
+   * The program and first arguments that run the Convex CLI, such as
+   * `["pnpm", "exec", "convex"]`. Code adds `deploy` and its flags. By
+   * default, the `convex` package that `cwd` resolves, run with this Node.js.
+   */
+  readonly command?: readonly [string, ...string[]];
+  /** Environment variables to set on the deployment before the push. Needs a deploy key of the deployment. */
+  readonly env?: Readonly<Record<string, string | Redacted.Redacted<string>>>;
+  /** `convex deploy --typecheck`. The CLI default is `try`. */
+  readonly typecheck?: "enable" | "try" | "disable";
+  /** `convex deploy --codegen`. The CLI default is `enable`. */
+  readonly codegen?: "enable" | "disable";
+}
+interface CodeAttributes {
+  /** The deployment that received the push, such as `happy-animal-123`. */
+  readonly deploymentName: string;
+  /** Client URL, such as `https://happy-animal-123.convex.cloud`. */
+  readonly url: string;
+  /** HTTP actions URL, such as `https://happy-animal-123.convex.site`. */
+  readonly siteUrl: string;
+  /** When the push finished, in milliseconds since the Unix epoch. */
+  readonly deployedAt: number;
+  /** The names of the `env` variables that this resource set on the deployment, sorted. */
+  readonly envNames: readonly string[];
+}
+type Code = Resource<"Convex.Code", CodeProps, CodeAttributes, never, Providers>;
+declare const Code: import("alchemy").ResourceClass<Code>;
+/** Reads the deployment URL from `convex deploy` output. ANSI escape codes are removed first. */
+declare const parseDeployOutput: (text: string) => {
+  url: string;
+  deploymentName: string;
+} | undefined;
+declare const DeployKeyMismatch_base: Schema.Class<DeployKeyMismatch, Schema.TaggedStruct<"DeployKeyMismatch", {
+  /** The deployment that should receive the push. */
+  readonly deployment: Schema.String;
+  /** What the key targets. */
+  readonly key: Schema.Literals<readonly ["deployment", "preview", "project", "unknown"]>;
+  /** For a deployment key: the deployment in the key prefix. Never the secret. */
+  readonly keyDeployment: Schema.UndefinedOr<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** The deploy key does not fit the deployment. Checked before the push. */
+declare class DeployKeyMismatch extends DeployKeyMismatch_base {
+  get message(): string;
+}
+declare const EnvironmentNeedsDeployKey_base: Schema.Class<EnvironmentNeedsDeployKey, Schema.TaggedStruct<"EnvironmentNeedsDeployKey", {
+  readonly deployment: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `env` needs the deployment API, which takes only a deploy key of the deployment. */
+declare class EnvironmentNeedsDeployKey extends EnvironmentNeedsDeployKey_base {
+  get message(): string;
+}
+declare const ConvexCliNotFound_base: Schema.Class<ConvexCliNotFound, Schema.TaggedStruct<"ConvexCliNotFound", {
+  readonly cwd: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** No `convex` package resolves from `cwd`. */
+declare class ConvexCliNotFound extends ConvexCliNotFound_base {
+  get message(): string;
+}
+declare const CodePushFailed_base: Schema.Class<CodePushFailed, Schema.TaggedStruct<"CodePushFailed", {
+  /** Exit code of the CLI. Undefined when it did not start or a signal stopped it. */
+  readonly exitCode: Schema.UndefinedOr<Schema.Number>;
+  /** The last lines of the CLI output, with the deploy key removed. */
+  readonly outputTail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The Convex CLI failed, or exited 0 without the deployment URL. The output tail never contains the key. */
+declare class CodePushFailed extends CodePushFailed_base {
+  get message(): string;
+}
+declare const PushTargetMismatch_base: Schema.Class<PushTargetMismatch, Schema.TaggedStruct<"PushTargetMismatch", {
+  readonly expected: Schema.String;
+  readonly actual: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The CLI pushed to another deployment than the one in the props. Checked after the push. */
+declare class PushTargetMismatch extends PushTargetMismatch_base {
+  get message(): string;
+}
+//#endregion
+//#region src/DefaultEnvironmentVariable.d.ts
+/** Deployment types a default can target, from the generated schema. */
+type DeploymentType = components["schemas"]["DeploymentType"];
+interface DefaultEnvironmentVariableProps {
+  /** Numeric project id, such as `project.projectId`. */
+  readonly projectId: number;
+  readonly name: string;
+  readonly value: string | Redacted.Redacted<string>;
+  /** Deployments of this type that Convex creates from now on get the variable. */
+  readonly deploymentType: DeploymentType;
+}
+interface DefaultEnvironmentVariableAttributes {
+  readonly projectId: number;
+  readonly name: string;
+  readonly deploymentType: DeploymentType;
+}
+type DefaultEnvironmentVariable = Resource<"Convex.DefaultEnvironmentVariable", DefaultEnvironmentVariableProps, DefaultEnvironmentVariableAttributes, never, Providers>;
+declare const DefaultEnvironmentVariable: import("alchemy").ResourceClass<DefaultEnvironmentVariable>;
+//#endregion
+//#region src/Deploy.d.ts
+interface DeployProps extends Pick<CommandRunProps, "cwd" | "env" | "timeout"> {
+  /**
+   * Deploy key that selects the target deployment: a production, development,
+   * project, or preview deploy key. The CLI receives it as `CONVEX_DEPLOY_KEY`,
+   * and Alchemy removes its value from the logged output.
+   */
+  readonly deployKey: Redacted.Redacted<string>;
+  /**
+   * Preview deployment name for a preview deploy key. The CLI reuses an
+   * existing preview deployment with this name.
+   */
+  readonly previewName?: string;
+  /**
+   * Like {@link previewName}, but the CLI deletes and recreates an existing
+   * preview deployment with this name, so every run gets a new URL.
+   */
+  readonly previewCreate?: string;
+  /**
+   * Function to run after the push, such as `init:seed`. The CLI runs it only
+   * when the push created a new preview deployment.
+   */
+  readonly previewRun?: string;
+  /**
+   * More `convex deploy` flags, added after the preview flags. Alchemy splits
+   * the command on whitespace, so an argument cannot contain whitespace: use
+   * `--typecheck=disable`, not `--typecheck disable` as one argument.
+   */
+  readonly extraArgs?: readonly string[];
+  /**
+   * Files hashed to skip an unchanged push. By default every non-gitignored
+   * file under `cwd` and the nearest lockfile. Use
+   * `{ include: ["convex/**"], lockfile: true }` to ignore frontend changes,
+   * or `false` to push on every deploy. A preview deploy (`previewName` or
+   * `previewCreate`) pushes on every deploy: Convex can delete an expired
+   * preview deployment, and the hash cannot show that.
+   * @default true
+   */
+  readonly memo?: MemoOptions | boolean;
+}
+interface DeployAttributes {
+  /** Client URL of the deployment that received the push, such as `https://happy-otter-123.convex.cloud`. */
+  readonly url: string;
+  /** First label of the URL host, such as `happy-otter-123`. */
+  readonly deploymentName: string;
+  /** Hash of the memoized input files after the push, or `undefined` when `memo` is `false`. */
+  readonly hash: string | undefined;
+}
+type Deploy = Resource<"Convex.Deploy", DeployProps, DeployAttributes, never, Providers>;
+/**
+ * @deprecated Since 0.3.0. Use Convex.Code with a Convex.Deployment: it
+ * runs the installed Convex CLI, keeps the deploy key out of the process
+ * environment, checks that the key fits the deployment, and outputs the site
+ * URL. Removing a Deploy resource changes nothing in Convex.
+ */
+declare const Deploy: import("alchemy").ResourceClass<Deploy>;
+/** The `convex deploy` argv, starting with `npx`. */
+declare const deployArgs: (props: Pick<DeployProps, "previewName" | "previewCreate" | "previewRun" | "extraArgs">) => readonly string[];
+declare const DeployArgumentError_base: Schema.Class<DeployArgumentError, Schema.TaggedStruct<"DeployArgumentError", {
+  readonly argument: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A `convex deploy` argument contains whitespace, which Alchemy's command runner splits on. */
+declare class DeployArgumentError extends DeployArgumentError_base {
+  get message(): string;
+}
+declare const DeployOutputError_base: Schema.Class<DeployOutputError, Schema.TaggedStruct<"DeployOutputError", {
+  readonly outputTail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `npx convex deploy` exited 0 but did not print the deployment URL. */
+declare class DeployOutputError extends DeployOutputError_base {
+  get message(): string;
+}
+//#endregion
+//#region src/DeployKey.d.ts
+/** Actions a deploy key can be limited to, from the generated schema. */
+type DeployKeyAction = NonNullable<components["schemas"]["PlatformCreateDeployKeyArgs"]["allowedActions"]>[number];
+declare const DeployKeyRecoveryRequired_base: Schema.Class<DeployKeyRecoveryRequired, Schema.TaggedStruct<"DeployKeyRecoveryRequired", {
+  /** Where the keys live, such as `deployment happy-otter-123` or `project 3145389`. */
+  readonly target: Schema.String;
+  /** The requested name. */
+  readonly name: Schema.String;
+  /** The listed keys with the requested name. */
+  readonly keys: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.Number;
+    readonly name: Schema.String;
+  }>>;
+  /** True when this run created a key before the listing check failed. */
+  readonly afterCreate: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A key cannot be tied to one resource: before the create, listed keys
+ * already have the requested name, or after the create, not exactly one has it.
+ */
+declare class DeployKeyRecoveryRequired extends DeployKeyRecoveryRequired_base {
+  get message(): string;
+}
+declare const DeployKeyIsCredential_base: Schema.Class<DeployKeyIsCredential, Schema.TaggedStruct<"DeployKeyIsCredential", {
+  readonly target: Schema.String;
+  readonly name: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Convex returned the Management API credential itself as the new key. This
+ * happens with an OAuth token: Convex creates no key. A delete of the
+ * returned secret would revoke the credential, so the resource does not keep it.
+ */
+declare class DeployKeyIsCredential extends DeployKeyIsCredential_base {
+  get message(): string;
+}
+interface DeployKeyProps {
+  /** Deployment name, such as `project.prodDeploymentName`. */
+  readonly deployment: string;
+  /**
+   * Key name. The provider requests this name, a dash, and a hash of the
+   * resource identity, so two resources with one `name` get different keys.
+   */
+  readonly name: string;
+  /** Limits the key to these actions. Convex grants every deployment action when omitted. */
+  readonly allowedActions?: readonly DeployKeyAction[];
+}
+interface DeployKeyAttributes {
+  /** The name Convex lists the key under, such as "ci-3f2a1b0c9d8e". */
+  readonly uniqueName: string;
+  /** Numeric id of the key in the listing. Undefined in state written by 0.1.x. */
+  readonly keyId: number | undefined;
+  readonly deployment: string;
+  /** The secret, such as `prod:<deployment>|<token>`. Convex returns it only at creation. */
+  readonly deployKey: Redacted.Redacted<string>;
+}
+type DeployKey = Resource<"Convex.DeployKey", DeployKeyProps, DeployKeyAttributes, never, Providers>;
+declare const DeployKey: import("alchemy").ResourceClass<DeployKey>;
+//#endregion
+//#region src/EnvironmentVariable.d.ts
+interface EnvironmentVariableProps {
+  /** Deployment name, or its URL for deployments outside US East. */
+  readonly deployment: string;
+  /** Deploy key for `deployment`, such as `deployKey.deployKey`. */
+  readonly deployKey: Redacted.Redacted<string>;
+  readonly name: string;
+  readonly value: string | Redacted.Redacted<string>;
+}
+interface EnvironmentVariableAttributes {
+  readonly deployment: string;
+  readonly name: string;
+  /** Deploy key for `deployment`, for read and delete. Undefined in state from 0.1.x. */
+  readonly deployKey: Redacted.Redacted<string> | undefined;
+}
+type EnvironmentVariable = Resource<"Convex.EnvironmentVariable", EnvironmentVariableProps, EnvironmentVariableAttributes, never, Providers>;
+declare const EnvironmentVariable: import("alchemy").ResourceClass<EnvironmentVariable>;
+declare const VariableIdentityChange_base: Schema.Class<VariableIdentityChange, Schema.TaggedStruct<"VariableIdentityChange", {
+  readonly resourceType: Schema.String;
+  readonly field: Schema.Literals<readonly ["name", "deployment", "projectId", "deploymentType"]>;
+  readonly current: Schema.String;
+  readonly requested: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The props name another variable than the one in state. Used by
+ * Convex.EnvironmentVariable and Convex.DefaultEnvironmentVariable.
+ */
+declare class VariableIdentityChange extends VariableIdentityChange_base {
+  get message(): string;
+}
+//#endregion
+//#region src/PreviewDeployKey.d.ts
+interface PreviewDeployKeyProps {
+  /** Numeric project id, such as `project.projectId`. */
+  readonly projectId: number;
+  /**
+   * Key name. The provider requests this name, a dash, and a hash of the
+   * resource identity, so two resources with one `name` get different keys.
+   */
+  readonly name: string;
+}
+interface PreviewDeployKeyAttributes {
+  /** The name Convex lists the key under, such as "ci-3f2a1b0c9d8e". */
+  readonly uniqueName: string;
+  /** Numeric id of the key in the listing. Undefined in state written by 0.1.x. */
+  readonly keyId: number | undefined;
+  readonly projectId: number;
+  /** The secret, such as `preview:<team>:<project>|<token>`. Convex returns it only at creation. */
+  readonly previewDeployKey: Redacted.Redacted<string>;
+}
+type PreviewDeployKey = Resource<"Convex.PreviewDeployKey", PreviewDeployKeyProps, PreviewDeployKeyAttributes, never, Providers>;
+declare const PreviewDeployKey: import("alchemy").ResourceClass<PreviewDeployKey>;
+//#endregion
+//#region src/Project.d.ts
+/** Region names the Management API accepts, from the generated schema. */
+type DeploymentRegion = components["schemas"]["RegionName"];
+interface ProjectProps {
+  /** Team slug or numeric team id. A slug costs one extra lookup per run. Cannot change. */
+  readonly team: string | number;
+  /** Display name. Convex derives the slug from it at creation. A change renames the project. */
+  readonly name: string;
+  /** Region of the deployment created with the project. Defaults to the team default. Cannot change. */
+  readonly deploymentRegion?: DeploymentRegion;
+  /** Deployment created with the project. Defaults to `prod`. Cannot change. */
+  readonly deploymentType?: "prod" | "dev";
+}
+interface ProjectAttributes {
+  readonly projectId: number;
+  readonly slug: string;
+  readonly name: string;
+  readonly teamId: number;
+  readonly prodDeploymentName: string | undefined;
+  readonly prodDeploymentUrl: string | undefined;
+}
+type Project = Resource<"Convex.Project", ProjectProps, ProjectAttributes, never, Providers>;
+declare const Project: import("alchemy").ResourceClass<Project>;
+declare const ProjectTeamChange_base: Schema.Class<ProjectTeamChange, Schema.TaggedStruct<"ProjectTeamChange", {
+  readonly projectId: Schema.Number;
+  readonly teamId: Schema.Number;
+  readonly requestedTeamId: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** The props change the team of an existing project. Convex cannot move a project. */
+declare class ProjectTeamChange extends ProjectTeamChange_base {
+  get message(): string;
+}
+declare const ProjectDeploymentChange_base: Schema.Class<ProjectDeploymentChange, Schema.TaggedStruct<"ProjectDeploymentChange", {
+  readonly projectId: Schema.Number;
+  readonly field: Schema.Literals<readonly ["deploymentType", "deploymentRegion"]>;
+  readonly current: Schema.UndefinedOr<Schema.String>;
+  readonly requested: Schema.UndefinedOr<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The props change `deploymentType` or `deploymentRegion` of an existing
+ * project. Convex uses them only when it creates the project.
+ */
+declare class ProjectDeploymentChange extends ProjectDeploymentChange_base {
+  get message(): string;
+}
+declare const AmbiguousProject_base: Schema.Class<AmbiguousProject, Schema.TaggedStruct<"AmbiguousProject", {
+  readonly teamId: Schema.Number;
+  readonly name: Schema.String;
+  readonly projectIds: Schema.$Array<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/** More than one project in the team has the name, so the lookup cannot choose one. */
+declare class AmbiguousProject extends AmbiguousProject_base {
+  get message(): string;
+}
+declare const CreatedProjectNotFound_base: Schema.Class<CreatedProjectNotFound, Schema.TaggedStruct<"CreatedProjectNotFound", {
+  readonly projectId: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** Convex answered a create call but then did not return the project. */
+declare class CreatedProjectNotFound extends CreatedProjectNotFound_base {
+  get message(): string;
+}
+//#endregion
+export { ACCESS_TOKEN_ENV, AmbiguousDeployment, AmbiguousProject, Code, type CodeAttributes, type CodeDeployment, type CodeProps, CodePushFailed, ConvexApiError, ConvexCliNotFound, CreatedProjectNotFound, Credentials, CredentialsError, DefaultEnvironmentVariable, type DefaultEnvironmentVariableAttributes, type DefaultEnvironmentVariableProps, Deploy, DeployArgumentError, type DeployAttributes, DeployKey, type DeployKeyAction, type DeployKeyAttributes, DeployKeyIsCredential, DeployKeyMismatch, type DeployKeyProps, DeployKeyRecoveryRequired, DeployOutputError, type DeployProps, Deployment, type DeploymentAttributes, DeploymentIdentityChange, type DeploymentProps, type DeploymentRegion, type DeploymentType, EnvironmentNeedsDeployKey, EnvironmentVariable, type EnvironmentVariableAttributes, type EnvironmentVariableProps, ManagementApi, PreviewDeployKey, type PreviewDeployKeyAttributes, type PreviewDeployKeyProps, ProductionDeploymentNotFound, Project, type ProjectAttributes, ProjectDeploymentChange, type ProjectProps, ProjectTeamChange, Providers, PushTargetMismatch, VariableIdentityChange, deployArgs, fromConfig, fromToken, parseDeployOutput, providers };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,0BAA0B,EAC1B,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,cAAc,GACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,MAAM,EACN,KAAK,gBAAgB,EACrB,UAAU,EACV,KAAK,WAAW,EAChB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,SAAS,EACT,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,mBAAmB,EACnB,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,GAC9B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EACL,gBAAgB,EAChB,KAAK,0BAA0B,EAC/B,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,gBAAgB,EACrB,OAAO,EACP,KAAK,iBAAiB,EACtB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/Credentials.ts","../src/ManagementApi.ts","../src/Providers.ts","../src/Deployment.ts","../src/Code.ts","../src/DefaultEnvironmentVariable.ts","../src/Deploy.ts","../src/DeployKey.ts","../src/EnvironmentVariable.ts","../src/PreviewDeployKey.ts","../src/Project.ts"],"mappings":"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"}