@rikalabs/akter-cli 0.0.0-stage → 0.1.0-alpha.3

package/dist/cloud-api/deployments.d.ts

@@ -0,0 +1,161 @@
+import { Schema } from "effect";
+/**
+ * Where a deployment is in its life.
+ *
+ * A new deployment starts `in-progress` and ends `live` or `failed`. When one
+ * becomes `live`, the deployment that was live in the same environment ends
+ * `drained` after a normal deploy, or `rolled-back` after a rollback. A failed
+ * deployment never replaces the live one.
+ */
+export declare const DeploymentStatus: Schema.Literals<readonly ["in-progress", "live", "drained", "rolled-back", "failed"]>;
+export type DeploymentStatus = typeof DeploymentStatus.Type;
+export declare const RolloutStepName: Schema.Literals<readonly ["build", "migrate", "start-runners", "drain-previous"]>;
+export type RolloutStepName = typeof RolloutStepName.Type;
+export declare const RolloutStep: Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["build", "migrate", "start-runners", "drain-previous"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "succeeded", "failed", "skipped"]>;
+    readonly durationMs: Schema.NullOr<Schema.Int>;
+    readonly detail: Schema.NullOr<Schema.String>;
+}>;
+export type RolloutStep = typeof RolloutStep.Type;
+export declare const DeploymentRunner: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly region: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+    readonly actorCount: Schema.NullOr<Schema.Int>;
+    readonly cpuPercent: Schema.NullOr<Schema.Finite>;
+    readonly health: Schema.Literals<readonly ["healthy", "unhealthy", "starting", "draining"]>;
+}>;
+export type DeploymentRunner = typeof DeploymentRunner.Type;
+export declare const DeploymentAuthor: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly image: Schema.NullOr<Schema.String>;
+}>;
+export type DeploymentAuthor = typeof DeploymentAuthor.Type;
+/**
+ * `rolledBackFrom` is null unless the deployment was created by a rollback, in
+ * which case it is the id of the earlier deployment whose image and
+ * environment snapshot it redeploys.
+ */
+export declare const DeploymentSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "DeploymentId">;
+    readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    /** The public environment host, omitted when the control plane has no runtime domain. */
+    readonly environmentHost: Schema.optional<Schema.String>;
+    readonly commitSha: Schema.String;
+    readonly message: Schema.String;
+    readonly author: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly image: Schema.NullOr<Schema.String>;
+    }>;
+    readonly regions: Schema.$Array<Schema.Literals<readonly ["us-east-1", "us-west-2"]>>;
+    readonly runnerCount: Schema.Int;
+    readonly durationMs: Schema.NullOr<Schema.Int>;
+    readonly status: Schema.Literals<readonly ["in-progress", "live", "drained", "rolled-back", "failed"]>;
+    readonly rolledBackFrom: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
+    readonly createdAt: Schema.DateTimeUtc;
+}>;
+export type DeploymentSummary = typeof DeploymentSummary.Type;
+export declare const DeploymentDetail: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "DeploymentId">;
+    readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    /** The public environment host, omitted when the control plane has no runtime domain. */
+    readonly environmentHost: Schema.optional<Schema.String>;
+    readonly commitSha: Schema.String;
+    readonly message: Schema.String;
+    readonly author: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly image: Schema.NullOr<Schema.String>;
+    }>;
+    readonly regions: Schema.$Array<Schema.Literals<readonly ["us-east-1", "us-west-2"]>>;
+    readonly runnerCount: Schema.Int;
+    readonly durationMs: Schema.NullOr<Schema.Int>;
+    readonly status: Schema.Literals<readonly ["in-progress", "live", "drained", "rolled-back", "failed"]>;
+    readonly rolledBackFrom: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly steps: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Literals<readonly ["build", "migrate", "start-runners", "drain-previous"]>;
+        readonly status: Schema.Literals<readonly ["pending", "running", "succeeded", "failed", "skipped"]>;
+        readonly durationMs: Schema.NullOr<Schema.Int>;
+        readonly detail: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly runners: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly region: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+        readonly actorCount: Schema.NullOr<Schema.Int>;
+        readonly cpuPercent: Schema.NullOr<Schema.Finite>;
+        readonly health: Schema.Literals<readonly ["healthy", "unhealthy", "starting", "draining"]>;
+    }>>;
+}>;
+export type DeploymentDetail = typeof DeploymentDetail.Type;
+/** A source archive's name: the SHA-256 of its gzip-compressed tar bytes. */
+export declare const SourceDigest: Schema.String;
+export type SourceDigest = typeof SourceDigest.Type;
+/** The most bytes one source archive may hold. */
+export declare const MAX_SOURCE_BYTES: number;
+/** A build context the project received, named by its digest. */
+export declare const SourceArchive: Schema.Struct<{
+    readonly digest: Schema.String;
+    readonly sizeBytes: Schema.Int;
+}>;
+export type SourceArchive = typeof SourceArchive.Type;
+/** The module inside an uploaded source that the managed host loads and serves. */
+export declare const SOURCE_ENTRY = "src/app.ts";
+/**
+ * What the control plane's builder builds a deployment from: an uploaded
+ * archive, launched from `SOURCE_ENTRY` with a Dockerfile the platform
+ * generates. A `dockerfile` field is refused rather than ignored, so a client
+ * that still names one learns its Dockerfile would not be used.
+ */
+export declare const DeploymentSource: Schema.Struct<{
+    readonly digest: Schema.String;
+    readonly dockerfile: Schema.optionalKey<Schema.Never>;
+}>;
+export type DeploymentSource = typeof DeploymentSource.Type;
+/**
+ * `source` names an archive sent with `uploadSource` for a control plane
+ * that builds deployments itself; without it, such a control plane builds its
+ * own configured context, and one without a builder waits for `RecordBuild`.
+ */
+export declare const CreateDeployment: Schema.Struct<{
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly commitSha: Schema.String;
+    readonly message: Schema.optional<Schema.String>;
+    readonly regions: Schema.optional<Schema.$Array<Schema.Literals<readonly ["us-east-1", "us-west-2"]>>>;
+    readonly source: Schema.optional<Schema.Struct<{
+        readonly digest: Schema.String;
+        readonly dockerfile: Schema.optionalKey<Schema.Never>;
+    }>>;
+}>;
+export type CreateDeployment = typeof CreateDeployment.Type;
+/** A content-addressed image makes a retry and a rollback use the same executable bytes. */
+export declare const ImageDigest: Schema.String;
+/** Records a successful external build and starts the durable rollout under the deployment id. */
+export declare const RecordBuild: Schema.Struct<{
+    readonly image: Schema.String;
+    readonly commitSha: Schema.String;
+    readonly environmentSnapshot: Schema.$Record<Schema.String, Schema.String>;
+}>;
+export type RecordBuild = typeof RecordBuild.Type;
+export declare const FailBuild: Schema.Struct<{
+    readonly reason: Schema.String;
+}>;
+export declare const BuildLogLine: Schema.Struct<{
+    readonly index: Schema.Int;
+    readonly at: Schema.DateTimeUtc;
+    readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+    readonly text: Schema.String;
+}>;
+export type BuildLogLine = typeof BuildLogLine.Type;
+/** Build output from `after` onward; `complete` is true once the build has ended and no later line will appear. */
+export declare const BuildLog: Schema.Struct<{
+    readonly lines: Schema.$Array<Schema.Struct<{
+        readonly index: Schema.Int;
+        readonly at: Schema.DateTimeUtc;
+        readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+        readonly text: Schema.String;
+    }>>;
+    readonly complete: Schema.Boolean;
+}>;
+export type BuildLog = typeof BuildLog.Type;

package/dist/cloud-api/errors.d.ts

@@ -0,0 +1,75 @@
+import { Schema } from "effect";
+declare const Unauthorized_base: Schema.Class<Unauthorized, Schema.TaggedStruct<"Unauthorized", {
+    readonly code: Schema.Literals<readonly ["missing_credentials", "invalid_credentials", "expired"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The credential is absent, wrong or past its expiry; answered 401. */
+export declare class Unauthorized extends Unauthorized_base {
+}
+declare const Forbidden_base: Schema.Class<Forbidden, Schema.TaggedStruct<"Forbidden", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The caller is known but its role or key permission does not allow the operation; answered 403. */
+export declare class Forbidden extends Forbidden_base {
+}
+/**
+ * What a `NotFound` names. `actor` is an actor address the live deployment
+ * does not have, `actor-type` a type it does not serve, `live deployment` an
+ * environment with nothing deployed, `command` a command the actor does
+ * not declare, and `source` a source archive the project was never sent, so a
+ * caller tells them apart without reading `id`.
+ */
+export declare const NotFoundResource: Schema.Literals<readonly ["actor", "actor-type", "api-key", "command", "cursor", "deployment", "domain", "environment", "invitation", "live deployment", "member", "organization", "project", "source"]>;
+export type NotFoundResource = typeof NotFoundResource.Type;
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
+    readonly resource: Schema.Literals<readonly ["actor", "actor-type", "api-key", "command", "cursor", "deployment", "domain", "environment", "invitation", "live deployment", "member", "organization", "project", "source"]>;
+    readonly id: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The resource does not exist or is not visible to the caller; answered 404. */
+export declare class NotFound extends NotFound_base {
+}
+declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflict", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The request conflicts with current state, such as a taken slug or a duplicate invitation; answered 409. */
+export declare class Conflict extends Conflict_base {
+}
+declare const NotImplemented_base: Schema.Class<NotImplemented, Schema.TaggedStruct<"NotImplemented", {
+    readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The endpoint is declared by the contract and has no implementation yet; answered 501. */
+export declare class NotImplemented extends NotImplemented_base {
+}
+/**
+ * Why a request is `Unavailable` when the cause is known and not an outage.
+ * `unknownPlan` means the organization's stored plan is not in the pricing
+ * configuration, an operator fault that retrying will not clear until the
+ * plan or the configuration is fixed.
+ */
+export declare const UnavailableReason: Schema.Literals<readonly ["unknownPlan"]>;
+export type UnavailableReason = typeof UnavailableReason.Type;
+declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"Unavailable", {
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Int;
+    readonly reason: Schema.optionalKey<Schema.Literals<readonly ["unknownPlan"]>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A deployment, its edge or a dependency is temporarily unavailable; callers
+ * retry with the same command identity. `reason` is set only when the cause
+ * is a known condition rather than an outage; a generic outage has none.
+ */
+export declare class Unavailable extends Unavailable_base {
+}
+declare const PayloadTooLarge_base: Schema.Class<PayloadTooLarge, Schema.TaggedStruct<"PayloadTooLarge", {
+    readonly limitBytes: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** The request body is larger than the endpoint accepts; answered 413 before the excess is read. */
+export declare class PayloadTooLarge extends PayloadTooLarge_base {
+}
+/** Errors every authenticated read can raise besides `Unauthorized`, which the middleware owns. */
+export declare const ReadErrors: readonly [typeof Forbidden, typeof NotFound, typeof NotImplemented, typeof Unavailable];
+/** Errors every mutation can raise besides `Unauthorized`, which the middleware owns. */
+export declare const WriteErrors: readonly [typeof Forbidden, typeof NotFound, typeof Conflict, typeof NotImplemented, typeof Unavailable];
+/** Errors for operations on no existing resource, such as listing the caller's own data. */
+export declare const SelfErrors: readonly [typeof Forbidden, typeof NotImplemented];
+export {};

package/dist/cloud-api/groups/account.d.ts

@@ -0,0 +1,370 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+declare const AccountGroup_base: HttpApiGroup.HttpApiGroup<"account", HttpApiEndpoint.HttpApiEndpoint<"deleteAccount", "DELETE", "/me", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly confirmation: Schema.brand<Schema.String, "Email">;
+}>>, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"exportData", "GET", "/me/export", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly userId: Schema.brand<Schema.String, "UserId">;
+    readonly exportedAt: Schema.DateTimeUtc;
+    readonly tables: Schema.$Record<Schema.String, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getNotifications", "GET", "/me/notifications", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly preferences: Schema.$Array<Schema.Struct<{
+        readonly event: Schema.Literals<readonly ["deploy_failed", "dead_letter", "spend_threshold"]>;
+        readonly email: Schema.Boolean;
+        readonly slack: Schema.Boolean;
+    }>>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getPreferences", "GET", "/me/preferences", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly defaultEnvironment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly openActorLinksInNewTab: Schema.Boolean;
+    readonly timeZone: Schema.String;
+    readonly pauseLiveTailOnScroll: Schema.Boolean;
+    readonly showReplayedCommands: Schema.Boolean;
+    readonly theme: Schema.Literals<readonly ["light", "dark", "system"]>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listPinnedActors", "GET", "/me/pinned-actors", never, Schema.toCodecStringTree<Schema.Struct<{
+    projectId: Schema.brand<Schema.String, "ProjectId">;
+    environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly address: Schema.String;
+    readonly status: Schema.Literals<readonly ["awake", "idle", "unknown"]>;
+    readonly lastActivityAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"me", "GET", "/me", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly user: Schema.NullOr<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "UserId">;
+        readonly name: Schema.String;
+        readonly email: Schema.brand<Schema.String, "Email">;
+        readonly emailVerified: Schema.Boolean;
+        readonly image: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly identityKind: Schema.Literals<readonly ["session", "api-key"]>;
+    readonly activeOrganizationId: Schema.NullOr<Schema.brand<Schema.String, "OrganizationId">>;
+    readonly organizations: Schema.$Array<Schema.Struct<{
+        readonly organization: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "OrganizationId">;
+            readonly name: Schema.String;
+            readonly slug: Schema.brand<Schema.String, "Slug">;
+            readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+                readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+            }>, Schema.TaggedStruct<"unknown", {
+                readonly id: Schema.String;
+            }>]>;
+            readonly createdAt: Schema.DateTimeUtc;
+        }>;
+        readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+    }>>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pinActor", "POST", "/me/pinned-actors", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly address: Schema.String;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly address: Schema.String;
+    readonly status: Schema.Literals<readonly ["awake", "idle", "unknown"]>;
+    readonly lastActivityAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"setActiveOrganization", "PUT", "/me/active-organization", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly organization: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly slug: Schema.brand<Schema.String, "Slug">;
+        readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+            readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        }>, Schema.TaggedStruct<"unknown", {
+            readonly id: Schema.String;
+        }>]>;
+        readonly createdAt: Schema.DateTimeUtc;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"setNotifications", "PUT", "/me/notifications", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly preferences: Schema.$Array<Schema.Struct<{
+        readonly event: Schema.Literals<readonly ["deploy_failed", "dead_letter", "spend_threshold"]>;
+        readonly email: Schema.Boolean;
+        readonly slack: Schema.Boolean;
+    }>>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly preferences: Schema.$Array<Schema.Struct<{
+        readonly event: Schema.Literals<readonly ["deploy_failed", "dead_letter", "spend_threshold"]>;
+        readonly email: Schema.Boolean;
+        readonly slack: Schema.Boolean;
+    }>>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"unpinActor", "DELETE", "/me/pinned-actors", never, Schema.toCodecStringTree<Schema.Struct<{
+    projectId: Schema.brand<Schema.String, "ProjectId">;
+    environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    address: Schema.String;
+}>>, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updatePreferences", "PATCH", "/me/preferences", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly defaultEnvironment: Schema.optional<Schema.Literals<readonly ["production", "staging", "dev"]>>;
+    readonly openActorLinksInNewTab: Schema.optional<Schema.Boolean>;
+    readonly timeZone: Schema.optional<Schema.String>;
+    readonly pauseLiveTailOnScroll: Schema.optional<Schema.Boolean>;
+    readonly showReplayedCommands: Schema.optional<Schema.Boolean>;
+    readonly theme: Schema.optional<Schema.Literals<readonly ["light", "dark", "system"]>>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly defaultEnvironment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly openActorLinksInNewTab: Schema.Boolean;
+    readonly timeZone: Schema.String;
+    readonly pauseLiveTailOnScroll: Schema.Boolean;
+    readonly showReplayedCommands: Schema.Boolean;
+    readonly theme: Schema.Literals<readonly ["light", "dark", "system"]>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateProfile", "PATCH", "/me", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly name: Schema.optional<Schema.brand<Schema.String, "Name">>;
+    readonly image: Schema.optional<Schema.NullOr<Schema.String>>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "UserId">;
+    readonly name: Schema.String;
+    readonly email: Schema.brand<Schema.String, "Email">;
+    readonly emailVerified: Schema.Boolean;
+    readonly image: Schema.NullOr<Schema.String>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never>, false>;
+export declare class AccountGroup extends AccountGroup_base {
+}
+declare const OrganizationsGroup_base: HttpApiGroup.HttpApiGroup<"organizations", HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/organizations", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "Name">;
+    readonly slug: Schema.brand<Schema.String, "Slug">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly organization: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly slug: Schema.brand<Schema.String, "Slug">;
+        readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+            readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        }>, Schema.TaggedStruct<"unknown", {
+            readonly id: Schema.String;
+        }>]>;
+        readonly createdAt: Schema.DateTimeUtc;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", "/organizations/:organizationId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/organizations/:organizationId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly organization: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly slug: Schema.brand<Schema.String, "Slug">;
+        readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+            readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        }>, Schema.TaggedStruct<"unknown", {
+            readonly id: Schema.String;
+        }>]>;
+        readonly createdAt: Schema.DateTimeUtc;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getDeletion", "GET", "/organizations/:organizationId/deletion", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    readonly phase: Schema.Literals<readonly ["billing", "runners", "databases", "records", "completed"]>;
+    readonly blocked: Schema.Boolean;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/organizations", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly organization: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly slug: Schema.brand<Schema.String, "Slug">;
+        readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+            readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        }>, Schema.TaggedStruct<"unknown", {
+            readonly id: Schema.String;
+        }>]>;
+        readonly createdAt: Schema.DateTimeUtc;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+}>>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotImplemented>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "PATCH", "/organizations/:organizationId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly name: Schema.optional<Schema.brand<Schema.String, "Name">>;
+    readonly slug: Schema.optional<Schema.brand<Schema.String, "Slug">>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "OrganizationId">;
+    readonly name: Schema.String;
+    readonly slug: Schema.brand<Schema.String, "Slug">;
+    readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+        readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+    }>, Schema.TaggedStruct<"unknown", {
+        readonly id: Schema.String;
+    }>]>;
+    readonly createdAt: Schema.DateTimeUtc;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never>, false>;
+export declare class OrganizationsGroup extends OrganizationsGroup_base {
+}
+declare const MembersGroup_base: HttpApiGroup.HttpApiGroup<"members", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/organizations/:organizationId/members", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "MemberId">;
+    readonly user: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "UserId">;
+        readonly name: Schema.String;
+        readonly email: Schema.brand<Schema.String, "Email">;
+        readonly image: Schema.NullOr<Schema.String>;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly lastActiveAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"remove", "DELETE", "/organizations/:organizationId/members/:memberId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    memberId: Schema.brand<Schema.String, "MemberId">;
+}>>, never, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateRole", "PATCH", "/organizations/:organizationId/members/:memberId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    memberId: Schema.brand<Schema.String, "MemberId">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "MemberId">;
+    readonly user: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "UserId">;
+        readonly name: Schema.String;
+        readonly email: Schema.brand<Schema.String, "Email">;
+        readonly image: Schema.NullOr<Schema.String>;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly lastActiveAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never>, false>;
+export declare class MembersGroup extends MembersGroup_base {
+}
+declare const InvitationsGroup_base: HttpApiGroup.HttpApiGroup<"invitations", HttpApiEndpoint.HttpApiEndpoint<"accept", "POST", "/invitations/:invitationId/accept", Schema.toCodecStringTree<Schema.Struct<{
+    invitationId: Schema.brand<Schema.String, "InvitationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly organization: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly slug: Schema.brand<Schema.String, "Slug">;
+        readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+            readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        }>, Schema.TaggedStruct<"unknown", {
+            readonly id: Schema.String;
+        }>]>;
+        readonly createdAt: Schema.DateTimeUtc;
+    }>;
+    readonly role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"cancel", "DELETE", "/organizations/:organizationId/invitations/:invitationId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    invitationId: Schema.brand<Schema.String, "InvitationId">;
+}>>, never, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/organizations/:organizationId/invitations", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly email: Schema.brand<Schema.String, "Email">;
+    readonly role: Schema.Literals<readonly ["admin", "member", "viewer"]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InvitationId">;
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    readonly email: Schema.brand<Schema.String, "Email">;
+    readonly role: Schema.Literals<readonly ["admin", "member", "viewer"]>;
+    readonly status: Schema.Literals<readonly ["pending", "accepted", "declined", "canceled", "expired"]>;
+    readonly invitedBy: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "UserId">;
+        readonly name: Schema.String;
+    }>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly expiresAt: Schema.DateTimeUtc;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"decline", "POST", "/invitations/:invitationId/decline", Schema.toCodecStringTree<Schema.Struct<{
+    invitationId: Schema.brand<Schema.String, "InvitationId">;
+}>>, never, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/organizations/:organizationId/invitations", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InvitationId">;
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    readonly email: Schema.brand<Schema.String, "Email">;
+    readonly role: Schema.Literals<readonly ["admin", "member", "viewer"]>;
+    readonly status: Schema.Literals<readonly ["pending", "accepted", "declined", "canceled", "expired"]>;
+    readonly invitedBy: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "UserId">;
+        readonly name: Schema.String;
+    }>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly expiresAt: Schema.DateTimeUtc;
+}>>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"preview", "GET", "/invitations/:invitationId", Schema.toCodecStringTree<Schema.Struct<{
+    invitationId: Schema.brand<Schema.String, "InvitationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InvitationId">;
+    readonly email: Schema.brand<Schema.String, "Email">;
+    readonly role: Schema.Literals<readonly ["admin", "member", "viewer"]>;
+    readonly status: Schema.Literals<readonly ["pending", "accepted", "declined", "canceled", "expired"]>;
+    readonly expiresAt: Schema.DateTimeUtc;
+    readonly inviterName: Schema.String;
+    readonly organization: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly slug: Schema.brand<Schema.String, "Slug">;
+        readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"unbound", {}>, Schema.TaggedStruct<"known", {
+            readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        }>, Schema.TaggedStruct<"unknown", {
+            readonly id: Schema.String;
+        }>]>;
+        readonly memberCount: Schema.Int;
+    }>;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resend", "POST", "/organizations/:organizationId/invitations/:invitationId/resend", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    invitationId: Schema.brand<Schema.String, "InvitationId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InvitationId">;
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    readonly email: Schema.brand<Schema.String, "Email">;
+    readonly role: Schema.Literals<readonly ["admin", "member", "viewer"]>;
+    readonly status: Schema.Literals<readonly ["pending", "accepted", "declined", "canceled", "expired"]>;
+    readonly invitedBy: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "UserId">;
+        readonly name: Schema.String;
+    }>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly expiresAt: Schema.DateTimeUtc;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never>, false>;
+export declare class InvitationsGroup extends InvitationsGroup_base {
+}
+declare const ApiKeysGroup_base: HttpApiGroup.HttpApiGroup<"apiKeys", HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/organizations/:organizationId/api-keys", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "Name">;
+    readonly permission: Schema.Literals<readonly ["read", "write", "admin"]>;
+    readonly projectId: Schema.optional<Schema.brand<Schema.String, "ProjectId">>;
+    readonly expiresAt: Schema.optional<Schema.DateTimeUtc>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly key: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ApiKeyId">;
+        readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+        readonly name: Schema.String;
+        readonly prefix: Schema.String;
+        readonly lastFour: Schema.String;
+        readonly permission: Schema.Literals<readonly ["read", "write", "admin"]>;
+        readonly projectId: Schema.NullOr<Schema.brand<Schema.String, "ProjectId">>;
+        readonly createdAt: Schema.DateTimeUtc;
+        readonly createdBy: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["user", "api-key"]>;
+            readonly id: Schema.String;
+            readonly name: Schema.NullOr<Schema.String>;
+        }>;
+        readonly lastUsedAt: Schema.NullOr<Schema.DateTimeUtc>;
+        readonly expiresAt: Schema.NullOr<Schema.DateTimeUtc>;
+        readonly revokedAt: Schema.NullOr<Schema.DateTimeUtc>;
+    }>;
+    readonly secret: Schema.String;
+}>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/organizations/:organizationId/api-keys", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    projectId: Schema.optional<Schema.brand<Schema.String, "ProjectId">>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ApiKeyId">;
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    readonly name: Schema.String;
+    readonly prefix: Schema.String;
+    readonly lastFour: Schema.String;
+    readonly permission: Schema.Literals<readonly ["read", "write", "admin"]>;
+    readonly projectId: Schema.NullOr<Schema.brand<Schema.String, "ProjectId">>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly createdBy: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["user", "api-key"]>;
+        readonly id: Schema.String;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>;
+    readonly lastUsedAt: Schema.NullOr<Schema.DateTimeUtc>;
+    readonly expiresAt: Schema.NullOr<Schema.DateTimeUtc>;
+    readonly revokedAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"revoke", "DELETE", "/organizations/:organizationId/api-keys/:keyId", Schema.toCodecStringTree<Schema.Struct<{
+    organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    keyId: Schema.brand<Schema.String, "ApiKeyId">;
+}>>, never, never, never, Schema.toCodecJson<import("effect/http-api/HttpApiSchema").NoContent>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never>, false>;
+export declare class ApiKeysGroup extends ApiKeysGroup_base {
+}
+export {};