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

package/dist/cloud-api/index.js

@@ -0,0 +1,1637 @@
+// ../../packages/cloud-api/src/errors.ts
+import { Schema } from "effect";
+
+class Unauthorized extends Schema.TaggedError()("Unauthorized", {
+  code: Schema.Literals(["missing_credentials", "invalid_credentials", "expired"]),
+  message: Schema.String
+}, { httpApiStatus: 401 }) {
+}
+
+class Forbidden extends Schema.TaggedError()("Forbidden", { message: Schema.String }, { httpApiStatus: 403 }) {
+}
+var NotFoundResource = Schema.Literals([
+  "actor",
+  "actor-type",
+  "api-key",
+  "command",
+  "cursor",
+  "deployment",
+  "domain",
+  "environment",
+  "invitation",
+  "live deployment",
+  "member",
+  "organization",
+  "project",
+  "source"
+]);
+
+class NotFound extends Schema.TaggedError()("NotFound", { resource: NotFoundResource, id: Schema.String }, { httpApiStatus: 404 }) {
+}
+
+class Conflict extends Schema.TaggedError()("Conflict", { message: Schema.String }, { httpApiStatus: 409 }) {
+}
+
+class NotImplemented extends Schema.TaggedError()("NotImplemented", { operation: Schema.String }, { httpApiStatus: 501 }) {
+}
+var UnavailableReason = Schema.Literals(["unknownPlan"]);
+
+class Unavailable extends Schema.TaggedError()("Unavailable", {
+  message: Schema.String,
+  retryAfterSeconds: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  reason: Schema.optionalKey(UnavailableReason)
+}, { httpApiStatus: 503 }) {
+}
+
+class PayloadTooLarge extends Schema.TaggedError()("PayloadTooLarge", { limitBytes: Schema.Int }, { httpApiStatus: 413 }) {
+}
+var ReadErrors = [Forbidden, NotFound, NotImplemented, Unavailable];
+var WriteErrors = [Forbidden, NotFound, Conflict, NotImplemented, Unavailable];
+var SelfErrors = [Forbidden, NotImplemented];
+// ../../packages/cloud-api/src/auth.ts
+import { Context, Schema as Schema3 } from "effect";
+import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api";
+
+// ../../packages/cloud-api/src/primitives.ts
+import { Schema as Schema2 } from "effect";
+var identifier = Schema2.String.pipe(Schema2.check(Schema2.isMinLength(1), Schema2.isMaxLength(128)));
+var UserId = identifier.pipe(Schema2.brand("UserId"));
+var OrganizationId = identifier.pipe(Schema2.brand("OrganizationId"));
+var MemberId = identifier.pipe(Schema2.brand("MemberId"));
+var InvitationId = identifier.pipe(Schema2.brand("InvitationId"));
+var ApiKeyId = identifier.pipe(Schema2.brand("ApiKeyId"));
+var ProjectId = identifier.pipe(Schema2.brand("ProjectId"));
+var DeploymentId = identifier.pipe(Schema2.brand("DeploymentId"));
+var DomainId = identifier.pipe(Schema2.brand("DomainId"));
+var DeadLetterId = identifier.pipe(Schema2.brand("DeadLetterId"));
+var InvoiceId = identifier.pipe(Schema2.brand("InvoiceId"));
+var EnvironmentId = identifier.pipe(Schema2.brand("EnvironmentId"));
+var Slug = Schema2.String.pipe(Schema2.check(Schema2.isPattern(/^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/)), Schema2.brand("Slug"));
+var Name = Schema2.String.pipe(Schema2.check(Schema2.isPattern(/^\S(?:.{0,98}\S)?$/)), Schema2.brand("Name"));
+var Email = Schema2.String.pipe(Schema2.check(Schema2.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/), Schema2.isMaxLength(254)), Schema2.brand("Email"));
+var NonNegativeInt = Schema2.Int.pipe(Schema2.check(Schema2.isGreaterThanOrEqualTo(0)));
+var NonNegative = Schema2.Finite.pipe(Schema2.check(Schema2.isGreaterThanOrEqualTo(0)));
+var Timestamp = Schema2.DateTimeUtc;
+var CalendarDay = Schema2.String.pipe(Schema2.check(Schema2.isPattern(/^\d{4}-\d{2}-\d{2}$/)));
+var BillingPeriod = Schema2.String.pipe(Schema2.check(Schema2.isPattern(/^\d{4}-(?:0[1-9]|1[0-2])$/)));
+var Role = Schema2.Literals(["owner", "admin", "member", "viewer"]);
+var InviteRole = Schema2.Literals(["admin", "member", "viewer"]);
+var EnvironmentName = Schema2.Literals(["production", "staging", "dev"]);
+var RegionId = Schema2.Literals(["us-east-1", "us-west-2"]);
+var CommitSha = Schema2.String.pipe(Schema2.check(Schema2.isPattern(/^[0-9a-f]{7,40}$/)));
+var ActorAddress = Schema2.String.pipe(Schema2.check(Schema2.isMinLength(3), Schema2.isMaxLength(1024), Schema2.isPattern(/^[^/]+\/.+$/)));
+var ActorReference = Schema2.Struct({
+  kind: Schema2.Literals(["user", "api-key"]),
+  id: Schema2.String,
+  name: Schema2.NullOr(Schema2.String)
+});
+var SeriesPoint = Schema2.Struct({ at: Timestamp, value: Schema2.Finite });
+var pageQuery = {
+  limit: Schema2.optional(Schema2.Int.pipe(Schema2.check(Schema2.isBetween({ minimum: 1, maximum: 100 })))),
+  cursor: Schema2.optional(Schema2.String)
+};
+var Page = (item) => Schema2.Struct({ items: Schema2.Array(item), nextCursor: Schema2.NullOr(Schema2.String) });
+
+// ../../packages/cloud-api/src/auth.ts
+var sessionCookieName = "better-auth.session_token";
+var secureSessionCookieName = "__Secure-better-auth.session_token";
+var apiKeyHeaderName = "x-api-key";
+var SessionIdentity = Schema3.TaggedStruct("session", {
+  userId: UserId,
+  sessionId: Schema3.String,
+  activeOrganizationId: Schema3.NullOr(OrganizationId)
+});
+var ApiKeyIdentity = Schema3.TaggedStruct("api-key", {
+  keyId: ApiKeyId,
+  organizationId: OrganizationId,
+  permission: Schema3.Literals(["read", "write", "admin"])
+});
+var Identity = Schema3.Union([SessionIdentity, ApiKeyIdentity]);
+
+class CurrentIdentity extends Context.Service()("@akter/cloud-api/auth/CurrentIdentity") {
+}
+
+class Authentication extends HttpApiMiddleware.Service()("@akter/cloud-api/Authentication", {
+  security: {
+    session: HttpApiSecurity.apiKey({ key: sessionCookieName, in: "cookie" }),
+    secureSession: HttpApiSecurity.apiKey({ key: secureSessionCookieName, in: "cookie" }),
+    apiKey: HttpApiSecurity.apiKey({ key: apiKeyHeaderName, in: "header" }),
+    bearer: HttpApiSecurity.bearer
+  },
+  error: [Unauthorized, Forbidden, Unavailable]
+}) {
+}
+// ../../packages/cloud-api/src/identity.ts
+import { Schema as Schema4 } from "effect";
+var PlanId = Schema4.Literals(["free", "pro", "team", "enterprise"]);
+var UnboundPlan = Schema4.TaggedStruct("unbound", {});
+var KnownPlan = Schema4.TaggedStruct("known", { id: PlanId });
+var UnknownPlan = Schema4.TaggedStruct("unknown", { id: Schema4.String });
+var OrganizationPlan = Schema4.Union([UnboundPlan, KnownPlan, UnknownPlan]);
+var User = Schema4.Struct({
+  id: UserId,
+  name: Schema4.String,
+  email: Email,
+  emailVerified: Schema4.Boolean,
+  image: Schema4.NullOr(Schema4.String)
+});
+var Organization = Schema4.Struct({
+  id: OrganizationId,
+  name: Schema4.String,
+  slug: Slug,
+  plan: OrganizationPlan,
+  createdAt: Timestamp
+});
+var OrganizationMembership = Schema4.Struct({
+  organization: Organization,
+  role: Role
+});
+var Me = Schema4.Struct({
+  user: Schema4.NullOr(User),
+  identityKind: Schema4.Literals(["session", "api-key"]),
+  activeOrganizationId: Schema4.NullOr(OrganizationId),
+  organizations: Schema4.Array(OrganizationMembership)
+});
+var UpdateProfile = Schema4.Struct({
+  name: Schema4.optional(Name),
+  image: Schema4.optional(Schema4.NullOr(Schema4.String))
+});
+var DeleteAccount = Schema4.Struct({ confirmation: Email });
+var PersonalDataExport = Schema4.Struct({
+  userId: UserId,
+  exportedAt: Timestamp,
+  tables: Schema4.Record(Schema4.String, Schema4.Array(Schema4.Json))
+});
+var OrganizationDeletion = Schema4.Struct({
+  organizationId: OrganizationId,
+  phase: Schema4.Literals(["billing", "runners", "databases", "records", "completed"]),
+  blocked: Schema4.Boolean
+});
+var SetActiveOrganization = Schema4.Struct({ organizationId: OrganizationId });
+var CreateOrganization = Schema4.Struct({ name: Name, slug: Slug });
+var UpdateOrganization = Schema4.Struct({
+  name: Schema4.optional(Name),
+  slug: Schema4.optional(Slug)
+});
+var MemberUser = Schema4.Struct({
+  id: UserId,
+  name: Schema4.String,
+  email: Email,
+  image: Schema4.NullOr(Schema4.String)
+});
+var Member = Schema4.Struct({
+  id: MemberId,
+  user: MemberUser,
+  role: Role,
+  createdAt: Timestamp,
+  lastActiveAt: Schema4.NullOr(Timestamp)
+});
+var UpdateMemberRole = Schema4.Struct({ role: Role });
+var InvitationStatus = Schema4.Literals([
+  "pending",
+  "accepted",
+  "declined",
+  "canceled",
+  "expired"
+]);
+var Invitation = Schema4.Struct({
+  id: InvitationId,
+  organizationId: OrganizationId,
+  email: Email,
+  role: InviteRole,
+  status: InvitationStatus,
+  invitedBy: Schema4.Struct({ id: UserId, name: Schema4.String }),
+  createdAt: Timestamp,
+  expiresAt: Timestamp
+});
+var CreateInvitation = Schema4.Struct({ email: Email, role: InviteRole });
+var InvitationPreview = Schema4.Struct({
+  id: InvitationId,
+  email: Email,
+  role: InviteRole,
+  status: InvitationStatus,
+  expiresAt: Timestamp,
+  inviterName: Schema4.String,
+  organization: Schema4.Struct({
+    id: OrganizationId,
+    name: Schema4.String,
+    slug: Slug,
+    plan: OrganizationPlan,
+    memberCount: NonNegativeInt
+  })
+});
+var ApiKeyPermission = Schema4.Literals(["read", "write", "admin"]);
+var ApiKey = Schema4.Struct({
+  id: ApiKeyId,
+  organizationId: OrganizationId,
+  name: Schema4.String,
+  prefix: Schema4.String,
+  lastFour: Schema4.String,
+  permission: ApiKeyPermission,
+  projectId: Schema4.NullOr(ProjectId),
+  createdAt: Timestamp,
+  createdBy: ActorReference,
+  lastUsedAt: Schema4.NullOr(Timestamp),
+  expiresAt: Schema4.NullOr(Timestamp),
+  revokedAt: Schema4.NullOr(Timestamp)
+});
+var CreateApiKey = Schema4.Struct({
+  name: Name,
+  permission: ApiKeyPermission,
+  projectId: Schema4.optional(ProjectId),
+  expiresAt: Schema4.optional(Timestamp)
+});
+var CreatedApiKey = Schema4.Struct({
+  key: ApiKey,
+  secret: Schema4.String
+});
+var Theme = Schema4.Literals(["light", "dark", "system"]);
+var Preferences = Schema4.Struct({
+  defaultEnvironment: EnvironmentName,
+  openActorLinksInNewTab: Schema4.Boolean,
+  timeZone: Schema4.String,
+  pauseLiveTailOnScroll: Schema4.Boolean,
+  showReplayedCommands: Schema4.Boolean,
+  theme: Theme
+});
+var UpdatePreferences = Schema4.Struct({
+  defaultEnvironment: Schema4.optional(EnvironmentName),
+  openActorLinksInNewTab: Schema4.optional(Schema4.Boolean),
+  timeZone: Schema4.optional(Schema4.String),
+  pauseLiveTailOnScroll: Schema4.optional(Schema4.Boolean),
+  showReplayedCommands: Schema4.optional(Schema4.Boolean),
+  theme: Schema4.optional(Theme)
+});
+var NotificationEvent = Schema4.Literals([
+  "deploy_failed",
+  "dead_letter",
+  "spend_threshold"
+]);
+var NotificationPreference = Schema4.Struct({
+  event: NotificationEvent,
+  email: Schema4.Boolean,
+  slack: Schema4.Boolean
+});
+var NotificationSettings = Schema4.Struct({
+  preferences: Schema4.Array(NotificationPreference)
+});
+var PinnedActor = Schema4.Struct({
+  projectId: ProjectId,
+  environment: EnvironmentName,
+  address: Schema4.String,
+  status: Schema4.Literals(["awake", "idle", "unknown"]),
+  lastActivityAt: Schema4.NullOr(Timestamp)
+});
+var PinActor = Schema4.Struct({
+  projectId: ProjectId,
+  environment: EnvironmentName,
+  address: Schema4.String
+});
+// ../../packages/cloud-api/src/projects.ts
+import { Schema as Schema5 } from "effect";
+var ProjectStatus = Schema5.Literals(["empty", "live", "deploying", "failed"]);
+var Region = Schema5.Struct({ id: RegionId, city: Schema5.String });
+var Project = Schema5.Struct({
+  id: ProjectId,
+  organizationId: OrganizationId,
+  name: Schema5.String,
+  slug: Slug,
+  status: ProjectStatus,
+  homeRegion: RegionId,
+  createdAt: Timestamp
+});
+var CreateProject = Schema5.Struct({ name: Name, slug: Slug, homeRegion: RegionId });
+var UpdateProject = Schema5.Struct({
+  name: Schema5.optional(Name),
+  slug: Schema5.optional(Slug)
+});
+var Environment = Schema5.Struct({
+  name: EnvironmentName,
+  projectId: ProjectId,
+  currentDeploymentId: Schema5.NullOr(DeploymentId),
+  database: Schema5.optionalKey(Schema5.Struct({
+    source: Schema5.Literal("customer"),
+    state: Schema5.Literals(["missing", "reachable", "unreachable"]),
+    latency: Schema5.NullOr(NonNegative),
+    latencyWarning: Schema5.Boolean,
+    runnerCap: Schema5.NullOr(Schema5.Int)
+  }))
+});
+var CreateEnvironment = Schema5.Struct({ name: EnvironmentName });
+var EnvVariable = Schema5.Struct({
+  name: Schema5.String,
+  usedBy: Schema5.Array(Schema5.String),
+  updatedAt: Timestamp,
+  updatedBy: Schema5.NullOr(ActorReference)
+});
+var EnvVariableName = Schema5.String.pipe(Schema5.check(Schema5.isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,255}$/)));
+var SetEnvVariable = Schema5.Struct({
+  value: Schema5.String.pipe(Schema5.check(Schema5.isMaxLength(65536)))
+});
+var ImportEnvVariables = Schema5.Struct({
+  content: Schema5.String.pipe(Schema5.check(Schema5.isMaxLength(1048576)))
+});
+var ImportEnvVariablesResult = Schema5.Struct({
+  created: Schema5.Array(Schema5.String),
+  updated: Schema5.Array(Schema5.String)
+});
+var DomainStatus = Schema5.Literals(["pending", "verifying", "active"]);
+var DnsRecord = Schema5.Struct({
+  type: Schema5.Literals(["A", "AAAA", "CNAME", "TXT"]),
+  name: Schema5.String,
+  value: Schema5.String
+});
+var Hostname = Schema5.String.pipe(Schema5.check(Schema5.isMaxLength(253), Schema5.isPattern(/^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/)));
+var Domain = Schema5.Struct({
+  id: DomainId,
+  hostname: Hostname,
+  environment: EnvironmentName,
+  status: DomainStatus,
+  dnsRecords: Schema5.Array(DnsRecord),
+  createdAt: Timestamp
+});
+var AddDomain = Schema5.Struct({ hostname: Hostname, environment: EnvironmentName });
+var OwnedTable = Schema5.Struct({
+  name: Schema5.String,
+  actor: Schema5.String,
+  rows: NonNegativeInt,
+  sizeBytes: NonNegativeInt,
+  region: RegionId
+});
+var ProjectRegion = Schema5.Struct({
+  region: Region,
+  home: Schema5.Boolean,
+  tenantCount: NonNegativeInt,
+  database: Schema5.Struct({ version: Schema5.String, sizeBytes: NonNegativeInt }),
+  storage: Schema5.Struct({ usedBytes: NonNegativeInt, limitBytes: NonNegativeInt }),
+  cpuPercent: NonNegative,
+  connections: Schema5.Struct({ used: NonNegativeInt, limit: NonNegativeInt }),
+  runners: NonNegativeInt,
+  largestTables: Schema5.Array(OwnedTable)
+});
+var AddRegion = Schema5.Struct({ region: RegionId });
+var SetHomeRegion = Schema5.Struct({ region: RegionId });
+var ProjectEndpoints = Schema5.Struct({
+  httpBaseUrl: Schema5.String,
+  webSocketUrl: Schema5.String,
+  openApiPath: Schema5.String,
+  mcpPath: Schema5.String
+});
+var IntegrationKind = Schema5.Literals([
+  "github",
+  "slack",
+  "datadog",
+  "opentelemetry",
+  "pagerduty"
+]);
+var Integration = Schema5.Struct({
+  kind: IntegrationKind,
+  status: Schema5.Literals(["connected", "disconnected", "error"]),
+  label: Schema5.NullOr(Schema5.String),
+  connectedAt: Schema5.NullOr(Timestamp)
+});
+var ConnectIntegration = Schema5.Struct({
+  settings: Schema5.optional(Schema5.Record(Schema5.String, Schema5.String))
+});
+var IntegrationConnection = Schema5.Struct({
+  redirectUrl: Schema5.NullOr(Schema5.String),
+  integration: Integration
+});
+// ../../packages/cloud-api/src/deployments.ts
+import { Schema as Schema6 } from "effect";
+var DeploymentStatus = Schema6.Literals([
+  "in-progress",
+  "live",
+  "drained",
+  "rolled-back",
+  "failed"
+]);
+var RolloutStepName = Schema6.Literals([
+  "build",
+  "migrate",
+  "start-runners",
+  "drain-previous"
+]);
+var RolloutStep = Schema6.Struct({
+  name: RolloutStepName,
+  status: Schema6.Literals(["pending", "running", "succeeded", "failed", "skipped"]),
+  durationMs: Schema6.NullOr(NonNegativeInt),
+  detail: Schema6.NullOr(Schema6.String)
+});
+var DeploymentRunner = Schema6.Struct({
+  id: Schema6.String,
+  region: RegionId,
+  actorCount: Schema6.NullOr(NonNegativeInt),
+  cpuPercent: Schema6.NullOr(NonNegative),
+  health: Schema6.Literals(["healthy", "unhealthy", "starting", "draining"])
+});
+var DeploymentAuthor = Schema6.Struct({
+  name: Schema6.String,
+  image: Schema6.NullOr(Schema6.String)
+});
+var DeploymentSummary = Schema6.Struct({
+  id: DeploymentId,
+  projectId: ProjectId,
+  environment: EnvironmentName,
+  environmentHost: Schema6.optional(Schema6.String),
+  commitSha: CommitSha,
+  message: Schema6.String,
+  author: DeploymentAuthor,
+  regions: Schema6.Array(RegionId),
+  runnerCount: NonNegativeInt,
+  durationMs: Schema6.NullOr(NonNegativeInt),
+  status: DeploymentStatus,
+  rolledBackFrom: Schema6.NullOr(DeploymentId),
+  createdAt: Timestamp
+});
+var DeploymentDetail = Schema6.Struct({
+  ...DeploymentSummary.fields,
+  steps: Schema6.Array(RolloutStep),
+  runners: Schema6.Array(DeploymentRunner)
+});
+var SourceDigest = Schema6.String.pipe(Schema6.check(Schema6.isPattern(/^sha256:[a-f0-9]{64}$/u)));
+var MAX_SOURCE_BYTES = 64 * 1024 * 1024;
+var SourceArchive = Schema6.Struct({
+  digest: SourceDigest,
+  sizeBytes: NonNegativeInt
+});
+var SOURCE_ENTRY = "src/app.ts";
+var DeploymentSource = Schema6.Struct({
+  digest: SourceDigest,
+  dockerfile: Schema6.optionalKey(Schema6.Never.annotate({
+    message: `source.dockerfile is not accepted: the platform builds every source from ${SOURCE_ENTRY}`
+  }))
+});
+var CreateDeployment = Schema6.Struct({
+  environment: EnvironmentName,
+  commitSha: CommitSha,
+  message: Schema6.optional(Schema6.String),
+  regions: Schema6.optional(Schema6.Array(RegionId)),
+  source: Schema6.optional(DeploymentSource)
+});
+var ImageDigest = Schema6.String.pipe(Schema6.check(Schema6.isPattern(/^(?:[^\s@]+@)?sha256:[a-f0-9]{64}$/u)));
+var RecordBuild = Schema6.Struct({
+  image: ImageDigest,
+  commitSha: CommitSha,
+  environmentSnapshot: Schema6.Record(Schema6.String, Schema6.String).check(Schema6.makeFilter((snapshot) => Object.keys(snapshot).every((key) => /^[A-Za-z_][A-Za-z0-9_]{0,254}$/u.test(key)) || "Environment variable names must be valid identifiers"))
+});
+var FailBuild = Schema6.Struct({
+  reason: Schema6.String.check(Schema6.isMinLength(1), Schema6.isMaxLength(4096))
+});
+var BuildLogLine = Schema6.Struct({
+  index: NonNegativeInt,
+  at: Timestamp,
+  stream: Schema6.Literals(["stdout", "stderr"]),
+  text: Schema6.String
+});
+var BuildLog = Schema6.Struct({
+  lines: Schema6.Array(BuildLogLine),
+  complete: Schema6.Boolean
+});
+// ../../packages/cloud-api/src/runtime.ts
+import * as Framework from "@rikalabs/akter/client";
+import { Schema as Schema7, Struct } from "effect";
+var SidebarCounts = Schema7.Struct({
+  actorTypes: NonNegativeInt,
+  openDeadLetters: NonNegativeInt
+});
+var Overview = Schema7.Struct({
+  commands: Schema7.NullOr(Schema7.Struct({
+    perSecond: NonNegative,
+    series24h: Schema7.Array(SeriesPoint),
+    p50Ms: Schema7.NullOr(NonNegative),
+    p99Ms: Schema7.NullOr(NonNegative)
+  })),
+  actors: Schema7.Struct({ awake: Schema7.NullOr(NonNegativeInt), total: NonNegativeInt }),
+  jobs: Schema7.Struct({ inFlight: NonNegativeInt, donePerHour: Schema7.NullOr(NonNegativeInt) }),
+  deadLettersByJobType: Schema7.Array(Schema7.Struct({ jobName: Schema7.String, count: NonNegativeInt })),
+  throughput: Schema7.NullOr(Schema7.Array(SeriesPoint)),
+  p99: Schema7.NullOr(Schema7.Array(SeriesPoint)),
+  health: Schema7.Struct({
+    runners: Schema7.NullOr(Schema7.Struct({ healthy: NonNegativeInt, total: NonNegativeInt })),
+    databaseCpuPercent: Schema7.NullOr(NonNegative),
+    maxMailbox: Schema7.NullOr(Schema7.Struct({ depth: NonNegativeInt, actor: Schema7.NullOr(ActorAddress) })),
+    parkedSockets: Schema7.NullOr(NonNegativeInt),
+    outboxLagP99Ms: Schema7.NullOr(NonNegative),
+    lastDeployAt: Schema7.NullOr(Timestamp)
+  }),
+  recentDeployments: Schema7.NullOr(Schema7.Array(DeploymentSummary))
+});
+var ActorTypeSummary = Schema7.Struct({
+  name: Schema7.String,
+  commands: Schema7.NullOr(Schema7.Array(Schema7.String)),
+  instances: NonNegativeInt,
+  awake: Schema7.NullOr(NonNegativeInt),
+  commandsPerSecond: Schema7.NullOr(NonNegative),
+  p99Ms: Schema7.NullOr(NonNegative),
+  maxMailbox: Schema7.NullOr(NonNegativeInt)
+});
+var SeriesWindow = Schema7.Literals(["1h", "24h", "7d"]);
+var CommandVolume = Schema7.Struct({
+  command: Schema7.String,
+  count: NonNegativeInt,
+  perSecond: NonNegative
+});
+var ActorTypeActivity = Schema7.Struct({
+  window: SeriesWindow,
+  since: Timestamp,
+  series: Schema7.Array(SeriesPoint),
+  commands: Schema7.Array(CommandVolume)
+});
+var LatencyBucket = Schema7.Struct({
+  upToMs: Schema7.NullOr(NonNegative),
+  count: NonNegativeInt
+});
+var TurnLatency = Schema7.Struct({
+  window: SeriesWindow,
+  since: Timestamp,
+  buckets: Schema7.Array(LatencyBucket),
+  p50Ms: Schema7.NullOr(NonNegative),
+  p95Ms: Schema7.NullOr(NonNegative),
+  p99Ms: Schema7.NullOr(NonNegative)
+});
+var ActorInstance = Schema7.Struct({
+  key: Schema7.String,
+  status: Schema7.NullOr(Schema7.Literals(["awake", "idle"])),
+  lastCommand: Schema7.NullOr(Schema7.String),
+  lastActivityAt: Schema7.NullOr(Timestamp),
+  generation: NonNegativeInt
+});
+var OwnedTableRows = Schema7.Struct({
+  table: Schema7.String,
+  columns: Schema7.Array(Schema7.String),
+  rows: Schema7.Array(Schema7.Array(Schema7.Json))
+});
+var CommandCaller = Schema7.Struct({
+  kind: Schema7.Literals(["user", "anonymous", "system"]),
+  subject: Schema7.NullOr(Schema7.String),
+  source: Schema7.NullOr(Schema7.String)
+});
+var Receipt = Schema7.Struct({
+  commandId: Schema7.String,
+  command: Schema7.String,
+  result: Schema7.NullOr(Schema7.String),
+  caller: Schema7.NullOr(CommandCaller),
+  at: Schema7.NullOr(Timestamp),
+  expiresAt: Timestamp,
+  replayed: Schema7.Boolean
+});
+var ActorEvent = Schema7.Struct({
+  name: Schema7.String,
+  cursor: Schema7.String,
+  emittedAt: Timestamp,
+  subscribers: Schema7.NullOr(NonNegativeInt)
+});
+var JobStatus = Schema7.Literals(["queued", "running", "retrying", "done", "dead"]);
+var ActorJob = Schema7.Struct({
+  name: Schema7.String,
+  id: Schema7.String,
+  attempts: NonNegativeInt,
+  status: JobStatus
+});
+var ActorTimelineEntry = Schema7.Struct({
+  at: Timestamp,
+  kind: Schema7.Literals(["command", "event", "job"]),
+  label: Schema7.String,
+  detail: Schema7.NullOr(Schema7.String),
+  caller: Schema7.NullOr(CommandCaller)
+});
+var ActorInspector = Schema7.Struct({
+  address: ActorAddress,
+  state: Schema7.Json,
+  turn: Schema7.NullOr(NonNegativeInt),
+  tables: Schema7.NullOr(Schema7.Array(OwnedTableRows)),
+  receipts: Schema7.Array(Receipt),
+  events: Schema7.Array(ActorEvent),
+  jobs: Schema7.Array(ActorJob),
+  connections: Schema7.Struct({
+    sockets: Schema7.NullOr(NonNegativeInt),
+    feedCursor: Schema7.NullOr(Schema7.String)
+  }),
+  properties: Schema7.Struct({
+    status: Schema7.NullOr(Schema7.Literals(["awake", "idle"])),
+    type: Schema7.String,
+    generation: NonNegativeInt,
+    runner: Schema7.NullOr(Schema7.String),
+    region: Schema7.NullOr(Schema7.String),
+    tenant: Schema7.String,
+    mailboxDepth: Schema7.NullOr(NonNegativeInt)
+  }),
+  timeline: Schema7.NullOr(Schema7.Array(ActorTimelineEntry))
+});
+var CommandOutcome = Schema7.Literals(["ok", "error", "replayed"]);
+var CommandLogEntry = Schema7.Struct({
+  commandId: Schema7.String,
+  at: Schema7.NullOr(Timestamp),
+  durationMs: Schema7.NullOr(NonNegative),
+  address: ActorAddress,
+  command: Schema7.String,
+  caller: Schema7.NullOr(CommandCaller),
+  payloadPreview: Schema7.NullOr(Schema7.String),
+  outcome: CommandOutcome,
+  errorTag: Schema7.NullOr(Schema7.String)
+});
+var commandName = Schema7.String.pipe(Schema7.check(Schema7.isMinLength(1), Schema7.isMaxLength(128)));
+var SendCommand = Schema7.Struct({
+  address: ActorAddress,
+  command: commandName,
+  payload: Schema7.Json,
+  commandId: Schema7.optional(commandName)
+});
+var CommandSent = Schema7.Struct({
+  commandId: Schema7.String,
+  result: Schema7.Json,
+  replayed: Schema7.Boolean
+});
+
+class CommandExpired extends Schema7.TaggedError()("CommandExpired", { commandId: Schema7.String }, { httpApiStatus: 410 }) {
+}
+
+class CommandStreamGap extends Schema7.TaggedError()("CommandStreamGap", {}) {
+}
+
+class RunnerDefect extends Schema7.TaggedError()("RunnerDefect", {}, { httpApiStatus: 502 }) {
+}
+
+class CommandRefused extends Schema7.TaggedError()("CommandRefused", {
+  commandId: Schema7.String,
+  reasonTag: Schema7.String,
+  reason: Framework.ActorError.fields.reason
+}, { httpApiStatus: 422 }) {
+}
+
+class CommandFailed extends Schema7.TaggedError()("CommandFailed", {
+  commandId: Schema7.String,
+  errorTag: Schema7.String,
+  error: Schema7.Json,
+  replayed: Schema7.Boolean
+}, { httpApiStatus: 422 }) {
+}
+
+class QuotaExceeded2 extends Schema7.TaggedError()("QuotaExceeded", Struct.omit(Framework.QuotaExceeded.fields, ["_tag"]), { httpApiStatus: 429 }) {
+}
+
+class QuotaUnbound extends Schema7.TaggedError()("QuotaUnbound", {
+  deployment: Schema7.String,
+  tenant: Schema7.String,
+  reason: Schema7.Literals(["tenant", "account", "plan"])
+}, { httpApiStatus: 402 }) {
+}
+var QuotaErrors = [QuotaExceeded2, QuotaUnbound];
+var JobTypeStats = Schema7.Struct({
+  jobName: Schema7.String,
+  done: Schema7.NullOr(NonNegativeInt),
+  retried: NonNegativeInt,
+  dead: NonNegativeInt,
+  p99Ms: Schema7.NullOr(NonNegative)
+});
+var JobsSummary = Schema7.Struct({
+  queued: NonNegativeInt,
+  running: Schema7.NullOr(NonNegativeInt),
+  retrying: NonNegativeInt,
+  dead: NonNegativeInt,
+  byType: Schema7.Array(JobTypeStats),
+  throughput: Schema7.NullOr(Schema7.Array(SeriesPoint))
+});
+var DeadLetter = Schema7.Struct({
+  id: DeadLetterId,
+  jobName: Schema7.String,
+  jobId: Schema7.String,
+  actor: ActorAddress,
+  attempts: NonNegativeInt,
+  lastError: Schema7.String,
+  since: Timestamp
+});
+var Workflow = Schema7.Struct({
+  id: Schema7.String,
+  name: Schema7.String,
+  actor: ActorAddress,
+  step: Schema7.NullOr(Schema7.Struct({
+    index: Schema7.Int.pipe(Schema7.check(Schema7.isGreaterThanOrEqualTo(1))),
+    total: Schema7.NullOr(Schema7.Int.pipe(Schema7.check(Schema7.isGreaterThanOrEqualTo(1)))),
+    name: Schema7.String
+  }).pipe(Schema7.check(Schema7.makeFilter((step) => step.total === null || step.index <= step.total || "step.index must not exceed step.total")))),
+  waitingFor: Schema7.NullOr(Schema7.Struct({ kind: Schema7.Literals(["event", "timer"]), name: Schema7.String })),
+  startedAt: Timestamp,
+  status: Schema7.NullOr(Schema7.Literals(["running", "waiting", "completed", "failed"]))
+});
+var TimersSummary = Schema7.Struct({
+  pending: NonNegativeInt,
+  nextFireAt: Schema7.NullOr(Timestamp)
+});
+var Schedule = Schema7.Struct({
+  name: Schema7.String,
+  actorPattern: Schema7.String,
+  cron: Schema7.String,
+  lastRun: Schema7.NullOr(Schema7.Struct({
+    at: Timestamp,
+    outcome: Schema7.Literals(["ok", "error"]),
+    durationMs: Schema7.NullOr(NonNegative)
+  })),
+  nextRunAt: Schema7.NullOr(Timestamp)
+});
+var ConnectionsSummary = Schema7.Struct({
+  open: NonNegativeInt,
+  parked: Schema7.NullOr(NonNegativeInt),
+  sseStreams: NonNegativeInt,
+  feedSubscribers: NonNegativeInt,
+  replayGaps: Schema7.NullOr(NonNegativeInt),
+  openVersusParked: Schema7.NullOr(Schema7.Array(Schema7.Struct({ at: Timestamp, open: NonNegativeInt, parked: NonNegativeInt }))),
+  byActorType: Schema7.Array(Schema7.Struct({
+    actorType: Schema7.String,
+    open: NonNegativeInt,
+    parked: Schema7.NullOr(NonNegativeInt),
+    sse: NonNegativeInt
+  }))
+});
+var SearchResult = Schema7.Struct({
+  kind: Schema7.Literals(["actor-type", "actor", "deployment"]),
+  id: Schema7.String,
+  title: Schema7.String,
+  subtitle: Schema7.NullOr(Schema7.String)
+});
+// ../../packages/cloud-api/src/billing.ts
+import { Schema as Schema8 } from "effect";
+var Plan = Schema8.TaggedStruct("known", {
+  id: PlanId,
+  name: Schema8.String,
+  basePriceCents: NonNegativeInt,
+  currency: Schema8.Literal("usd"),
+  renewsAt: Schema8.NullOr(Timestamp),
+  monthToDateEstimateCents: NonNegativeInt,
+  provisional: Schema8.optionalKey(Schema8.Boolean),
+  subscribedId: Schema8.optionalKey(PlanId),
+  paymentStatus: Schema8.optionalKey(Schema8.Literals(["free", "active", "past_due", "unpaid", "canceled", "incomplete"]))
+});
+var CardPaymentMethod = Schema8.TaggedStruct("card", {
+  brand: Schema8.String,
+  lastFour: Schema8.String,
+  expiryMonth: Schema8.Int.pipe(Schema8.check(Schema8.isBetween({ minimum: 1, maximum: 12 }))),
+  expiryYear: NonNegativeInt
+});
+var LinkPaymentMethod = Schema8.TaggedStruct("link", {
+  email: Schema8.NullOr(Schema8.String)
+});
+var PaymentMethod = Schema8.Union([CardPaymentMethod, LinkPaymentMethod]);
+var SpendLimit = Schema8.Struct({
+  limitCents: Schema8.NullOr(NonNegativeInt),
+  currentSpendCents: NonNegativeInt
+});
+var capFields = {
+  limit: Schema8.NullOr(NonNegative),
+  used: NonNegative,
+  atCap: Schema8.Boolean,
+  refusing: Schema8.Boolean,
+  reason: Schema8.optionalKey(Schema8.Literal("unbound"))
+};
+var CapState = Schema8.Struct({
+  cap: Schema8.Literals(["spend", "connections", "compute"]),
+  ...capFields
+});
+var BillingSummary = Schema8.Struct({
+  plan: Schema8.Union([Plan, UnboundPlan]),
+  paymentMethod: Schema8.NullOr(PaymentMethod),
+  billingEmail: Schema8.NullOr(Email),
+  spendLimit: SpendLimit,
+  caps: Schema8.optionalKey(Schema8.Array(CapState))
+});
+var SetSpendLimit = Schema8.Struct({ limitCents: Schema8.NullOr(NonNegativeInt) });
+var Invoice = Schema8.Struct({
+  id: InvoiceId,
+  number: Schema8.String,
+  periodStart: Timestamp,
+  periodEnd: Timestamp,
+  amountCents: NonNegativeInt,
+  currency: Schema8.Literal("usd"),
+  status: Schema8.Literals(["draft", "open", "paid", "void", "uncollectible"]),
+  pdfUrl: Schema8.NullOr(Schema8.String)
+});
+var StartCheckout = Schema8.Struct({ plan: Schema8.Literals(["pro", "team", "enterprise"]) });
+var PlanChange = Schema8.Struct({
+  requestId: Schema8.String,
+  status: Schema8.Literals(["pending", "completed", "failed"])
+});
+var HostedSession = Schema8.Struct({ url: Schema8.String });
+var machineSizeFields = {
+  cpuKind: Schema8.Literals(["shared", "performance"]),
+  cpus: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1)),
+  memoryMb: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1))
+};
+var PlanFeature = Schema8.Literals([
+  "compute-overage",
+  "compute-cap",
+  "byo-database",
+  "checkout"
+]);
+var CatalogPlan = Schema8.Struct({
+  id: PlanId,
+  name: Schema8.String,
+  basePriceCents: NonNegativeInt,
+  currency: Schema8.Literal("usd"),
+  allowances: Schema8.Struct({
+    computeUnitHours: NonNegative,
+    computeUnitHourCap: Schema8.NullOr(NonNegative),
+    concurrentConnections: NonNegativeInt
+  }),
+  overage: Schema8.Struct({
+    computeCentsPerUnitHour: NonNegative
+  }),
+  features: Schema8.Array(PlanFeature),
+  provisional: Schema8.Boolean
+});
+var ComputeSize = Schema8.Struct({
+  ...machineSizeFields,
+  unitsPerHour: Schema8.Finite.check(Schema8.isGreaterThan(0))
+});
+var PlanCatalog = Schema8.Struct({
+  plans: Schema8.Array(CatalogPlan),
+  computeSizes: Schema8.Array(ComputeSize),
+  provisional: Schema8.Boolean
+});
+var UsageMeterName = Schema8.Literal("runnerHours");
+var UsageMeter = Schema8.Struct({
+  meter: UsageMeterName,
+  used: NonNegative,
+  included: NonNegative,
+  overage: NonNegative,
+  overageCostCents: NonNegative
+});
+var UsagePricing = Schema8.Struct({
+  computeCentsPerUnitHour: NonNegative,
+  provisional: Schema8.optionalKey(Schema8.Boolean)
+});
+var ComputeUsage = Schema8.Struct({
+  environmentId: EnvironmentId,
+  ...machineSizeFields,
+  machineHours: NonNegative,
+  computeUnitHours: NonNegative
+});
+var Usage = Schema8.Struct({
+  period: BillingPeriod,
+  meters: Schema8.Array(UsageMeter),
+  caps: Schema8.Array(CapState),
+  byProject: Schema8.Array(Schema8.Struct({
+    projectId: ProjectId,
+    name: Schema8.String,
+    computeUnitHours: NonNegative,
+    compute: Schema8.Array(ComputeUsage),
+    estimatedCostCents: NonNegative
+  })),
+  pricing: UsagePricing
+});
+var AuditEntry = Schema8.Struct({
+  id: Schema8.String,
+  at: Timestamp,
+  actor: ActorReference,
+  action: Schema8.String,
+  target: Schema8.Struct({
+    type: Schema8.String,
+    id: Schema8.NullOr(Schema8.String),
+    name: Schema8.NullOr(Schema8.String)
+  }),
+  ipAddress: Schema8.NullOr(Schema8.String)
+});
+// ../../packages/cloud-api/src/contract.ts
+import { HttpApi, OpenApi as OpenApi3 } from "effect/http-api";
+
+// ../../packages/cloud-api/src/groups/account.ts
+import { Schema as Schema9 } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+var organizationParams = { organizationId: OrganizationId };
+
+class AccountGroup extends HttpApiGroup.make("account").add(HttpApiEndpoint.get("me", "/me", { success: Me, error: SelfErrors }), HttpApiEndpoint.get("exportData", "/me/export", {
+  success: PersonalDataExport,
+  error: SelfErrors
+}), HttpApiEndpoint.delete("deleteAccount", "/me", {
+  payload: DeleteAccount,
+  error: WriteErrors
+}), HttpApiEndpoint.patch("updateProfile", "/me", {
+  payload: UpdateProfile,
+  success: User,
+  error: SelfErrors
+}), HttpApiEndpoint.put("setActiveOrganization", "/me/active-organization", {
+  payload: SetActiveOrganization,
+  success: OrganizationMembership,
+  error: WriteErrors
+}), HttpApiEndpoint.get("getPreferences", "/me/preferences", {
+  success: Preferences,
+  error: SelfErrors
+}), HttpApiEndpoint.patch("updatePreferences", "/me/preferences", {
+  payload: UpdatePreferences,
+  success: Preferences,
+  error: SelfErrors
+}), HttpApiEndpoint.get("getNotifications", "/me/notifications", {
+  success: NotificationSettings,
+  error: SelfErrors
+}), HttpApiEndpoint.put("setNotifications", "/me/notifications", {
+  payload: NotificationSettings,
+  success: NotificationSettings,
+  error: SelfErrors
+}), HttpApiEndpoint.get("listPinnedActors", "/me/pinned-actors", {
+  query: { projectId: ProjectId, environment: EnvironmentName },
+  success: Schema9.Array(PinnedActor),
+  error: ReadErrors
+}), HttpApiEndpoint.post("pinActor", "/me/pinned-actors", {
+  payload: PinActor,
+  success: PinnedActor,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("unpinActor", "/me/pinned-actors", {
+  query: { projectId: ProjectId, environment: EnvironmentName, address: Schema9.String },
+  error: WriteErrors
+})) {
+}
+
+class OrganizationsGroup extends HttpApiGroup.make("organizations").add(HttpApiEndpoint.get("list", "/organizations", {
+  success: Schema9.Array(OrganizationMembership),
+  error: SelfErrors
+}), HttpApiEndpoint.post("create", "/organizations", {
+  payload: CreateOrganization,
+  success: OrganizationMembership,
+  error: WriteErrors
+}), HttpApiEndpoint.get("get", "/organizations/:organizationId", {
+  params: organizationParams,
+  success: OrganizationMembership,
+  error: ReadErrors
+}), HttpApiEndpoint.patch("update", "/organizations/:organizationId", {
+  params: organizationParams,
+  payload: UpdateOrganization,
+  success: Organization,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("delete", "/organizations/:organizationId", {
+  params: organizationParams,
+  error: WriteErrors
+}), HttpApiEndpoint.get("getDeletion", "/organizations/:organizationId/deletion", {
+  params: organizationParams,
+  success: OrganizationDeletion,
+  error: ReadErrors
+})) {
+}
+
+class MembersGroup extends HttpApiGroup.make("members").add(HttpApiEndpoint.get("list", "/organizations/:organizationId/members", {
+  params: organizationParams,
+  success: Schema9.Array(Member),
+  error: ReadErrors
+}), HttpApiEndpoint.patch("updateRole", "/organizations/:organizationId/members/:memberId", {
+  params: { ...organizationParams, memberId: MemberId },
+  payload: UpdateMemberRole,
+  success: Member,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("remove", "/organizations/:organizationId/members/:memberId", {
+  params: { ...organizationParams, memberId: MemberId },
+  error: WriteErrors
+})) {
+}
+
+class InvitationsGroup extends HttpApiGroup.make("invitations").add(HttpApiEndpoint.get("list", "/organizations/:organizationId/invitations", {
+  params: organizationParams,
+  success: Schema9.Array(Invitation),
+  error: ReadErrors
+}), HttpApiEndpoint.post("create", "/organizations/:organizationId/invitations", {
+  params: organizationParams,
+  payload: CreateInvitation,
+  success: Invitation,
+  error: WriteErrors
+}), HttpApiEndpoint.post("resend", "/organizations/:organizationId/invitations/:invitationId/resend", {
+  params: { ...organizationParams, invitationId: InvitationId },
+  success: Invitation,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("cancel", "/organizations/:organizationId/invitations/:invitationId", {
+  params: { ...organizationParams, invitationId: InvitationId },
+  error: WriteErrors
+}), HttpApiEndpoint.get("preview", "/invitations/:invitationId", {
+  params: { invitationId: InvitationId },
+  success: InvitationPreview,
+  error: ReadErrors
+}), HttpApiEndpoint.post("accept", "/invitations/:invitationId/accept", {
+  params: { invitationId: InvitationId },
+  success: OrganizationMembership,
+  error: WriteErrors
+}), HttpApiEndpoint.post("decline", "/invitations/:invitationId/decline", {
+  params: { invitationId: InvitationId },
+  error: WriteErrors
+})) {
+}
+
+class ApiKeysGroup extends HttpApiGroup.make("apiKeys").add(HttpApiEndpoint.get("list", "/organizations/:organizationId/api-keys", {
+  params: organizationParams,
+  query: { projectId: Schema9.optional(ProjectId) },
+  success: Schema9.Array(ApiKey),
+  error: ReadErrors
+}), HttpApiEndpoint.post("create", "/organizations/:organizationId/api-keys", {
+  params: organizationParams,
+  payload: CreateApiKey,
+  success: CreatedApiKey,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("revoke", "/organizations/:organizationId/api-keys/:keyId", {
+  params: { ...organizationParams, keyId: ApiKeyId },
+  error: WriteErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/billing.ts
+import { Schema as Schema10 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint2, HttpApiGroup as HttpApiGroup2 } from "effect/http-api";
+var organizationParams2 = { organizationId: OrganizationId };
+
+class BillingGroup extends HttpApiGroup2.make("billing").add(HttpApiEndpoint2.get("listPlans", "/billing/plans", {
+  success: PlanCatalog,
+  error: SelfErrors
+}), HttpApiEndpoint2.get("get", "/organizations/:organizationId/billing", {
+  params: organizationParams2,
+  success: BillingSummary,
+  error: ReadErrors
+}), HttpApiEndpoint2.get("listInvoices", "/organizations/:organizationId/billing/invoices", {
+  params: organizationParams2,
+  success: Schema10.Array(Invoice),
+  error: ReadErrors
+}), HttpApiEndpoint2.put("setSpendLimit", "/organizations/:organizationId/billing/spend-limit", {
+  params: organizationParams2,
+  payload: SetSpendLimit,
+  success: SpendLimit,
+  error: WriteErrors
+}), HttpApiEndpoint2.post("startCheckout", "/organizations/:organizationId/billing/checkout", {
+  params: organizationParams2,
+  payload: StartCheckout,
+  success: HostedSession,
+  error: WriteErrors
+}), HttpApiEndpoint2.post("changePlan", "/organizations/:organizationId/billing/plan", {
+  params: organizationParams2,
+  payload: StartCheckout,
+  success: PlanChange,
+  error: WriteErrors
+}), HttpApiEndpoint2.post("openPortal", "/organizations/:organizationId/billing/portal", {
+  params: organizationParams2,
+  success: HostedSession,
+  error: WriteErrors
+})) {
+}
+
+class UsageGroup extends HttpApiGroup2.make("usage").add(HttpApiEndpoint2.get("get", "/organizations/:organizationId/usage", {
+  params: organizationParams2,
+  query: { period: Schema10.optional(BillingPeriod) },
+  success: Usage,
+  error: ReadErrors
+})) {
+}
+
+class AuditGroup extends HttpApiGroup2.make("audit").add(HttpApiEndpoint2.get("list", "/organizations/:organizationId/audit-log", {
+  params: organizationParams2,
+  query: {
+    ...pageQuery,
+    action: Schema10.optional(Schema10.String),
+    actorId: Schema10.optional(Schema10.String)
+  },
+  success: Page(AuditEntry),
+  error: ReadErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/deployments.ts
+import { Schema as Schema12 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint3, HttpApiGroup as HttpApiGroup3, HttpApiSchema, OpenApi } from "effect/http-api";
+
+// ../../packages/cloud-api/src/logs.ts
+import { Schema as Schema11 } from "effect";
+var MAX_LOG_LINES = 200;
+var MAX_LOG_TEXT_BYTES = 4096;
+var MAX_LOG_WINDOW_SECONDS = 3600;
+var MAX_LOG_WAIT_SECONDS = 20;
+var LogCursor = Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(2048));
+var LogLimit = Schema11.Int.check(Schema11.isBetween({ minimum: 1, maximum: MAX_LOG_LINES }));
+var LogWait = Schema11.Int.check(Schema11.isBetween({ minimum: 0, maximum: MAX_LOG_WAIT_SECONDS }));
+var logQuery = {
+  since: Schema11.optional(Timestamp),
+  limit: Schema11.optional(LogLimit),
+  cursor: Schema11.optional(LogCursor),
+  wait: Schema11.optional(LogWait)
+};
+var RunnerLogLine = Schema11.Struct({
+  id: Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(512)),
+  deploymentId: DeploymentId,
+  runnerId: Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(256)),
+  at: Timestamp,
+  stream: Schema11.Literals(["stdout", "stderr", "unknown"]),
+  text: Schema11.String.check(Schema11.makeFilter((text) => new TextEncoder().encode(text).byteLength <= MAX_LOG_TEXT_BYTES || "Log text exceeds the byte limit")),
+  clipped: Schema11.Boolean
+});
+var RunnerLogPage = Schema11.Struct({
+  lines: Schema11.Array(RunnerLogLine).check(Schema11.isMaxLength(MAX_LOG_LINES)),
+  cursor: LogCursor,
+  more: Schema11.Boolean
+});
+
+// ../../packages/cloud-api/src/groups/deployments.ts
+var projectParams = { projectId: ProjectId };
+var deploymentParams = { ...projectParams, deploymentId: DeploymentId };
+
+class DeploymentsGroup extends HttpApiGroup3.make("deployments").add(HttpApiEndpoint3.get("getEnvironmentLogs", "/projects/:projectId/environments/:environment/logs", {
+  params: { ...projectParams, environment: EnvironmentName },
+  query: logQuery,
+  success: RunnerLogPage,
+  error: ReadErrors
+}).annotate(OpenApi.Description, "Reads recent stdout/stderr from the environment's current deployment. Authorization is checked on every read, including resumed polls, and suspended organizations remain readable. Defaults: since five minutes ago, limit 100, wait 0. The server clamps since to the past hour through now, so network delay and client clock skew do not reject a window boundary; limit is 1–200 and wait is 0–20 seconds. A cursor, at most 2048 characters, resumes the same authorized resource and takes precedence over since. More means another page is immediately available: continue with the cursor and wait 0 until more is false, then follow with wait 20. A current-deployment change switches environment follow to the new deployment and resets its provider position, retaining the original bounded window. Provider retention is recent and best-effort, not an archive. No current deployment returns an empty page. Text is clipped at 4096 UTF-8 bytes; each line's clipped flag reports that independently of more."), HttpApiEndpoint3.get("getLogs", "/projects/:projectId/deployments/:deploymentId/logs", {
+  params: deploymentParams,
+  query: logQuery,
+  success: RunnerLogPage,
+  error: ReadErrors
+}).annotate(OpenApi.Description, "Reads only the authorized deployment's customer runner stdout/stderr, with the same bounds and cursor protocol as environment logs. A deployment from another project or organization is not visible. Runner identifiers come only from the deployment's stored runner records, never from the cursor or caller input."), HttpApiEndpoint3.get("list", "/projects/:projectId/deployments", {
+  params: projectParams,
+  query: {
+    ...pageQuery,
+    environment: Schema12.optional(EnvironmentName),
+    status: Schema12.optional(DeploymentStatus)
+  },
+  success: Page(DeploymentSummary),
+  error: ReadErrors
+}), HttpApiEndpoint3.post("create", "/projects/:projectId/deployments", {
+  params: projectParams,
+  payload: CreateDeployment,
+  success: DeploymentDetail,
+  error: WriteErrors
+}), HttpApiEndpoint3.post("uploadSource", "/projects/:projectId/sources", {
+  params: projectParams,
+  payload: Schema12.Uint8Array.pipe(HttpApiSchema.asUint8Array({ contentType: "application/gzip" })),
+  success: SourceArchive,
+  error: [...WriteErrors, PayloadTooLarge]
+}).annotate(OpenApi.Description, "Stores a gzip-compressed tar of a build context for the project and answers its digest, the SHA-256 of the bytes sent. Sending the same bytes again answers the same digest. A deployment created with `source` naming that digest is built from it by the control plane's builder. Access and the builder are checked before the body is read: a caller without write access answers 403 and a control plane without a builder 501 `NotImplemented`. A body over 64 MiB answers 413 `PayloadTooLarge`, before any byte is read when its `content-length` says so, and as soon as it passes the limit otherwise."), HttpApiEndpoint3.get("get", "/projects/:projectId/deployments/:deploymentId", {
+  params: deploymentParams,
+  success: DeploymentDetail,
+  error: ReadErrors
+}), HttpApiEndpoint3.post("recordBuild", "/projects/:projectId/deployments/:deploymentId/build", {
+  params: deploymentParams,
+  payload: RecordBuild,
+  success: DeploymentDetail,
+  error: WriteErrors
+}), HttpApiEndpoint3.post("failBuild", "/projects/:projectId/deployments/:deploymentId/build-failure", {
+  params: deploymentParams,
+  payload: FailBuild,
+  success: DeploymentDetail,
+  error: WriteErrors
+}), HttpApiEndpoint3.get("getBuildLog", "/projects/:projectId/deployments/:deploymentId/build-log", {
+  params: deploymentParams,
+  query: { after: Schema12.optional(NonNegativeInt) },
+  success: BuildLog,
+  error: ReadErrors
+}), HttpApiEndpoint3.post("rollback", "/projects/:projectId/deployments/:deploymentId/rollback", {
+  params: deploymentParams,
+  success: DeploymentDetail,
+  error: WriteErrors
+}).annotate(OpenApi.Description, "Rolls the environment back to the earlier deployment named by `deploymentId`. That deployment must have reached `live` before (status `live`, `drained` or `rolled-back`) and must not be the one live now; otherwise the answer is 409. The build is not repeated: a new deployment in the same environment redeploys that deployment's image and environment-variable snapshot, its `rolledBackFrom` is `deploymentId`, and its build and migrate steps are `skipped`. The new deployment starts `in-progress` and becomes `live` or `failed`. When it becomes `live`, the deployment that was live ends `rolled-back`; if it fails, that deployment stays `live`. The target keeps its own status. A second rollout in the environment while one is `in-progress` answers 409. The response is the new deployment."), HttpApiEndpoint3.post("redeploy", "/projects/:projectId/deployments/:deploymentId/redeploy", {
+  params: deploymentParams,
+  success: DeploymentDetail,
+  error: WriteErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/projects.ts
+import { Schema as Schema13 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint4, HttpApiGroup as HttpApiGroup4 } from "effect/http-api";
+var projectParams2 = { projectId: ProjectId };
+var environmentParams = { ...projectParams2, environment: EnvironmentName };
+
+class ProjectsGroup extends HttpApiGroup4.make("projects").add(HttpApiEndpoint4.get("list", "/organizations/:organizationId/projects", {
+  params: { organizationId: OrganizationId },
+  success: Schema13.Array(Project),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("create", "/organizations/:organizationId/projects", {
+  params: { organizationId: OrganizationId },
+  payload: CreateProject,
+  success: Project,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("get", "/projects/:projectId", {
+  params: projectParams2,
+  success: Project,
+  error: ReadErrors
+}), HttpApiEndpoint4.patch("update", "/projects/:projectId", {
+  params: projectParams2,
+  payload: UpdateProject,
+  success: Project,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("delete", "/projects/:projectId", {
+  params: projectParams2,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("listEnvironments", "/projects/:projectId/environments", {
+  params: projectParams2,
+  success: Schema13.Array(Environment),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("createEnvironment", "/projects/:projectId/environments", {
+  params: projectParams2,
+  payload: CreateEnvironment,
+  success: Environment,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("getEnvironment", "/projects/:projectId/environments/:environment", {
+  params: environmentParams,
+  success: Environment,
+  error: ReadErrors
+}), HttpApiEndpoint4.delete("deleteEnvironment", "/projects/:projectId/environments/:environment", {
+  params: environmentParams,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("getEndpoints", "/projects/:projectId/environments/:environment/endpoints", {
+  params: environmentParams,
+  success: ProjectEndpoints,
+  error: ReadErrors
+})) {
+}
+
+class EnvironmentVariablesGroup extends HttpApiGroup4.make("environmentVariables").add(HttpApiEndpoint4.get("list", "/projects/:projectId/environments/:environment/variables", {
+  params: environmentParams,
+  success: Schema13.Array(EnvVariable),
+  error: ReadErrors
+}), HttpApiEndpoint4.put("set", "/projects/:projectId/environments/:environment/variables/:name", {
+  params: { ...environmentParams, name: EnvVariableName },
+  payload: SetEnvVariable,
+  success: EnvVariable,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("delete", "/projects/:projectId/environments/:environment/variables/:name", {
+  params: { ...environmentParams, name: EnvVariableName },
+  error: WriteErrors
+}), HttpApiEndpoint4.post("import", "/projects/:projectId/environments/:environment/variables/import", {
+  params: environmentParams,
+  payload: ImportEnvVariables,
+  success: ImportEnvVariablesResult,
+  error: WriteErrors
+})) {
+}
+
+class DomainsGroup extends HttpApiGroup4.make("domains").add(HttpApiEndpoint4.get("list", "/projects/:projectId/domains", {
+  params: projectParams2,
+  success: Schema13.Array(Domain),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("add", "/projects/:projectId/domains", {
+  params: projectParams2,
+  payload: AddDomain,
+  success: Domain,
+  error: WriteErrors
+}), HttpApiEndpoint4.post("verify", "/projects/:projectId/domains/:domainId/verify", {
+  params: { ...projectParams2, domainId: DomainId },
+  success: Domain,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("remove", "/projects/:projectId/domains/:domainId", {
+  params: { ...projectParams2, domainId: DomainId },
+  error: WriteErrors
+})) {
+}
+
+class RegionsGroup extends HttpApiGroup4.make("regions").add(HttpApiEndpoint4.get("catalog", "/regions", {
+  success: Schema13.Array(Region),
+  error: ReadErrors
+}), HttpApiEndpoint4.get("list", "/projects/:projectId/environments/:environment/regions", {
+  params: environmentParams,
+  success: Schema13.Array(ProjectRegion),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("add", "/projects/:projectId/regions", {
+  params: projectParams2,
+  payload: AddRegion,
+  success: Region,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("remove", "/projects/:projectId/regions/:region", {
+  params: { ...projectParams2, region: RegionId },
+  error: WriteErrors
+}), HttpApiEndpoint4.put("setHome", "/projects/:projectId/home-region", {
+  params: projectParams2,
+  payload: SetHomeRegion,
+  success: Project,
+  error: WriteErrors
+})) {
+}
+
+class IntegrationsGroup extends HttpApiGroup4.make("integrations").add(HttpApiEndpoint4.get("list", "/projects/:projectId/integrations", {
+  params: projectParams2,
+  success: Schema13.Array(Integration),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("connect", "/projects/:projectId/integrations/:kind", {
+  params: { ...projectParams2, kind: IntegrationKind },
+  payload: ConnectIntegration,
+  success: IntegrationConnection,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("disconnect", "/projects/:projectId/integrations/:kind", {
+  params: { ...projectParams2, kind: IntegrationKind },
+  error: WriteErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/runtime.ts
+import { Schema as Schema14 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint5, HttpApiGroup as HttpApiGroup5, HttpApiSchema as HttpApiSchema2, OpenApi as OpenApi2 } from "effect/http-api";
+var environmentParams2 = { projectId: ProjectId, environment: EnvironmentName };
+var actorTypeParams = { ...environmentParams2, actorType: Schema14.String };
+var actorParams = { ...actorTypeParams, key: Schema14.String };
+var InspectErrors = [...ReadErrors, RunnerDefect];
+
+class RuntimeGroup extends HttpApiGroup5.make("runtime").add(HttpApiEndpoint5.get("getOverview", "/projects/:projectId/environments/:environment/runtime/overview", {
+  params: environmentParams2,
+  success: Overview,
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getSidebarCounts", "/projects/:projectId/environments/:environment/runtime/sidebar-counts", { params: environmentParams2, success: SidebarCounts, error: InspectErrors }), HttpApiEndpoint5.get("search", "/projects/:projectId/environments/:environment/runtime/search", {
+  params: environmentParams2,
+  query: { q: Schema14.String.pipe(Schema14.check(Schema14.isMinLength(1), Schema14.isMaxLength(256))) },
+  success: Schema14.Array(SearchResult),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listActorTypes", "/projects/:projectId/environments/:environment/runtime/actor-types", {
+  params: environmentParams2,
+  success: Schema14.Array(ActorTypeSummary),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getActorType", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType", { params: actorTypeParams, success: ActorTypeSummary, error: InspectErrors }), HttpApiEndpoint5.get("getActorTypeActivity", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType/activity", {
+  params: actorTypeParams,
+  query: { window: Schema14.optional(SeriesWindow) },
+  success: ActorTypeActivity,
+  error: InspectErrors
+}).annotate(OpenApi2.Description, "Commands per second over the window (default 24h) and the volume of each command, for one actor type, as the serving runner counted them since `since`. `NotImplemented` while more than one runner serves the environment."), HttpApiEndpoint5.get("getActorTypeLatency", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType/latency", {
+  params: actorTypeParams,
+  query: { window: Schema14.optional(SeriesWindow) },
+  success: TurnLatency,
+  error: InspectErrors
+}).annotate(OpenApi2.Description, "Turn-latency histogram over the window (default 24h) with p50, p95 and p99, for one actor type, as the serving runner measured them since `since`. `NotImplemented` while more than one runner serves the environment."), HttpApiEndpoint5.get("listActorInstances", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType/instances", {
+  params: actorTypeParams,
+  query: { ...pageQuery, status: Schema14.optional(Schema14.Literals(["awake", "idle"])) },
+  success: Page(ActorInstance),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("inspectActor", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key", { params: actorParams, success: ActorInspector, error: InspectErrors }), HttpApiEndpoint5.get("listActorTables", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/tables", { params: actorParams, success: Schema14.Array(OwnedTableRows), error: ReadErrors }), HttpApiEndpoint5.get("listActorReceipts", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/receipts", { params: actorParams, query: pageQuery, success: Page(Receipt), error: InspectErrors }), HttpApiEndpoint5.get("listActorEvents", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/events", { params: actorParams, success: Schema14.Array(ActorEvent), error: InspectErrors }), HttpApiEndpoint5.get("listActorJobs", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/jobs", { params: actorParams, success: Schema14.Array(ActorJob), error: InspectErrors }), HttpApiEndpoint5.get("listActorTimeline", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/timeline", {
+  params: actorParams,
+  query: pageQuery,
+  success: Page(ActorTimelineEntry),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listCommands", "/projects/:projectId/environments/:environment/runtime/commands", {
+  params: environmentParams2,
+  query: {
+    ...pageQuery,
+    actorType: Schema14.optional(Schema14.String),
+    outcome: Schema14.optional(CommandOutcome)
+  },
+  success: Page(CommandLogEntry),
+  error: InspectErrors
+}), HttpApiEndpoint5.post("sendCommand", "/projects/:projectId/environments/:environment/runtime/commands", {
+  params: environmentParams2,
+  payload: SendCommand,
+  success: CommandSent,
+  error: [
+    ...WriteErrors,
+    CommandFailed,
+    CommandRefused,
+    CommandExpired,
+    RunnerDefect,
+    ...QuotaErrors
+  ]
+}).annotate(OpenApi2.Description, "Sends to an actor address, including one not yet created, without requiring an inspector read. Requires project write permission. `commandId` is an optional client idempotency key, not a runner command id. Its scope is organization/project/environment/actor address/command, independent of deployment. The control plane durably assigns a runner-minted id and stores only a canonical payload hash; the same key and JSON input reuse it and replay the receipt with `replayed: true` within the runner's retry window. Different input returns 409 Conflict. After expiry, the key is retained as a tombstone for 30 days and returns 410 `CommandExpired`; reusing it after that starts a new command. Declared actor errors are 422 CommandFailed; admission refusals are typed 4xx, including 422 CommandRefused. Mailbox backpressure remains 503 Unavailable. Remote defects are opaque, non-retryable 502 RunnerDefect errors. The edge's usage refusals keep the framework's tags and payloads: a full Free command quota is a 429 `QuotaExceeded`, a passed spend limit a 402 `SpendLimitExceeded`, a full connection allowance a 429 `ConnectionLimitExceeded` and a Free tenant at its storage cap a 429 `StorageQuotaExceeded`. A command the edge cannot bill, because the tenant has no organization, the organization no billing account, or its plan is not in the pricing configuration, is a 402 `QuotaUnbound` carrying that reason, never a generic 503."), HttpApiEndpoint5.get("streamCommands", "/projects/:projectId/environments/:environment/runtime/commands/stream", {
+  params: environmentParams2,
+  query: {
+    actorType: Schema14.optional(Schema14.String),
+    outcome: Schema14.optional(CommandOutcome)
+  },
+  success: HttpApiSchema2.StreamSse({
+    data: Schema14.toCodecJson(CommandLogEntry),
+    error: CommandStreamGap
+  }),
+  error: InspectErrors
+}).annotate(OpenApi2.Description, "Each command the serving runner commits from now on, filtered by actor type and outcome (`replayed` is always empty, since a replay commits no turn), with a payload preview of at most 256 characters that the runner cut and redacted. The control plane resumes across the runner's credential expiry; the stream fails with `CommandStreamGap` when the runner can no longer resume it without missing commands, and ends when the runner goes away; a client reconnects. `NotImplemented` while more than one runner serves the environment."), HttpApiEndpoint5.get("getJobs", "/projects/:projectId/environments/:environment/runtime/jobs", {
+  params: environmentParams2,
+  success: JobsSummary,
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listDeadLetters", "/projects/:projectId/environments/:environment/runtime/dead-letters", {
+  params: environmentParams2,
+  query: pageQuery,
+  success: Page(DeadLetter),
+  error: InspectErrors
+}), HttpApiEndpoint5.post("retryDeadLetter", "/projects/:projectId/environments/:environment/runtime/dead-letters/:deadLetterId/retry", {
+  params: { ...environmentParams2, deadLetterId: DeadLetterId },
+  error: WriteErrors
+}), HttpApiEndpoint5.post("discardDeadLetter", "/projects/:projectId/environments/:environment/runtime/dead-letters/:deadLetterId/discard", {
+  params: { ...environmentParams2, deadLetterId: DeadLetterId },
+  error: WriteErrors
+}), HttpApiEndpoint5.get("listWorkflows", "/projects/:projectId/environments/:environment/runtime/workflows", {
+  params: environmentParams2,
+  query: {
+    ...pageQuery,
+    status: Schema14.optional(Schema14.Literals(["running", "waiting", "completed", "failed"]))
+  },
+  success: Page(Workflow),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getTimers", "/projects/:projectId/environments/:environment/runtime/timers", {
+  params: environmentParams2,
+  success: TimersSummary,
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listSchedules", "/projects/:projectId/environments/:environment/runtime/schedules", {
+  params: environmentParams2,
+  success: Schema14.Array(Schedule),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getConnections", "/projects/:projectId/environments/:environment/runtime/connections", { params: environmentParams2, success: ConnectionsSummary, error: InspectErrors })) {
+}
+
+// ../../packages/cloud-api/src/contract.ts
+class CloudApi extends HttpApi.make("akter-cloud").add(AccountGroup, OrganizationsGroup, MembersGroup, InvitationsGroup, ApiKeysGroup, ProjectsGroup, EnvironmentVariablesGroup, DomainsGroup, RegionsGroup, IntegrationsGroup, DeploymentsGroup, RuntimeGroup, BillingGroup, UsageGroup, AuditGroup).middleware(Authentication).prefix("/api").annotateMerge(OpenApi3.annotations({ title: "Akter Cloud API" })) {
+}
+export {
+  AccountGroup,
+  ActorAddress,
+  ActorEvent,
+  ActorInspector,
+  ActorInstance,
+  ActorJob,
+  ActorReference,
+  ActorTimelineEntry,
+  ActorTypeActivity,
+  ActorTypeSummary,
+  AddDomain,
+  AddRegion,
+  ApiKey,
+  ApiKeyId,
+  ApiKeyIdentity,
+  ApiKeyPermission,
+  ApiKeysGroup,
+  AuditEntry,
+  AuditGroup,
+  Authentication,
+  BillingGroup,
+  BillingPeriod,
+  BillingSummary,
+  BuildLog,
+  BuildLogLine,
+  CalendarDay,
+  CapState,
+  CardPaymentMethod,
+  CatalogPlan,
+  CloudApi,
+  CommandCaller,
+  CommandExpired,
+  CommandFailed,
+  CommandLogEntry,
+  CommandOutcome,
+  CommandRefused,
+  CommandSent,
+  CommandStreamGap,
+  CommandVolume,
+  CommitSha,
+  ComputeSize,
+  ComputeUsage,
+  Conflict,
+  ConnectIntegration,
+  ConnectionsSummary,
+  CreateApiKey,
+  CreateDeployment,
+  CreateEnvironment,
+  CreateInvitation,
+  CreateOrganization,
+  CreateProject,
+  CreatedApiKey,
+  CurrentIdentity,
+  DeadLetter,
+  DeadLetterId,
+  DeleteAccount,
+  DeploymentAuthor,
+  DeploymentDetail,
+  DeploymentId,
+  DeploymentRunner,
+  DeploymentSource,
+  DeploymentStatus,
+  DeploymentSummary,
+  DeploymentsGroup,
+  DnsRecord,
+  Domain,
+  DomainId,
+  DomainStatus,
+  DomainsGroup,
+  Email,
+  EnvVariable,
+  EnvVariableName,
+  Environment,
+  EnvironmentId,
+  EnvironmentName,
+  EnvironmentVariablesGroup,
+  FailBuild,
+  Forbidden,
+  HostedSession,
+  Hostname,
+  Identity,
+  ImageDigest,
+  ImportEnvVariables,
+  ImportEnvVariablesResult,
+  Integration,
+  IntegrationConnection,
+  IntegrationKind,
+  IntegrationsGroup,
+  Invitation,
+  InvitationId,
+  InvitationPreview,
+  InvitationStatus,
+  InvitationsGroup,
+  InviteRole,
+  Invoice,
+  InvoiceId,
+  JobStatus,
+  JobTypeStats,
+  JobsSummary,
+  KnownPlan,
+  LatencyBucket,
+  LinkPaymentMethod,
+  LogCursor,
+  LogLimit,
+  LogWait,
+  MAX_LOG_LINES,
+  MAX_LOG_TEXT_BYTES,
+  MAX_LOG_WAIT_SECONDS,
+  MAX_LOG_WINDOW_SECONDS,
+  MAX_SOURCE_BYTES,
+  Me,
+  Member,
+  MemberId,
+  MemberUser,
+  MembersGroup,
+  Name,
+  NonNegative,
+  NonNegativeInt,
+  NotFound,
+  NotFoundResource,
+  NotImplemented,
+  NotificationEvent,
+  NotificationPreference,
+  NotificationSettings,
+  Organization,
+  OrganizationDeletion,
+  OrganizationId,
+  OrganizationMembership,
+  OrganizationPlan,
+  OrganizationsGroup,
+  Overview,
+  OwnedTable,
+  OwnedTableRows,
+  Page,
+  PayloadTooLarge,
+  PaymentMethod,
+  PersonalDataExport,
+  PinActor,
+  PinnedActor,
+  Plan,
+  PlanCatalog,
+  PlanChange,
+  PlanFeature,
+  PlanId,
+  Preferences,
+  Project,
+  ProjectEndpoints,
+  ProjectId,
+  ProjectRegion,
+  ProjectStatus,
+  ProjectsGroup,
+  QuotaErrors,
+  QuotaExceeded2 as QuotaExceeded,
+  QuotaUnbound,
+  ReadErrors,
+  Receipt,
+  RecordBuild,
+  Region,
+  RegionId,
+  RegionsGroup,
+  Role,
+  RolloutStep,
+  RolloutStepName,
+  RunnerDefect,
+  RunnerLogLine,
+  RunnerLogPage,
+  RuntimeGroup,
+  SOURCE_ENTRY,
+  Schedule,
+  SearchResult,
+  SelfErrors,
+  SendCommand,
+  SeriesPoint,
+  SeriesWindow,
+  SessionIdentity,
+  SetActiveOrganization,
+  SetEnvVariable,
+  SetHomeRegion,
+  SetSpendLimit,
+  SidebarCounts,
+  Slug,
+  SourceArchive,
+  SourceDigest,
+  SpendLimit,
+  StartCheckout,
+  Theme,
+  TimersSummary,
+  Timestamp,
+  TurnLatency,
+  Unauthorized,
+  Unavailable,
+  UnavailableReason,
+  UnboundPlan,
+  UnknownPlan,
+  UpdateMemberRole,
+  UpdateOrganization,
+  UpdatePreferences,
+  UpdateProfile,
+  UpdateProject,
+  Usage,
+  UsageGroup,
+  UsageMeter,
+  UsageMeterName,
+  UsagePricing,
+  User,
+  UserId,
+  Workflow,
+  WriteErrors,
+  apiKeyHeaderName,
+  logQuery,
+  pageQuery,
+  secureSessionCookieName,
+  sessionCookieName
+};