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

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

@@ -0,0 +1,347 @@
+import { Schema } from "effect";
+/**
+ * The plan of an organization with a billing account, tagged `known` like the
+ * organization's `KnownPlan`, so `Plan | UnboundPlan` is a tagged union.
+ */
+export declare const Plan: Schema.TaggedStruct<"known", {
+    readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+    readonly name: Schema.String;
+    readonly basePriceCents: Schema.Int;
+    readonly currency: Schema.Literal<"usd">;
+    readonly renewsAt: Schema.NullOr<Schema.DateTimeUtc>;
+    readonly monthToDateEstimateCents: Schema.Int;
+    readonly provisional: Schema.optionalKey<Schema.Boolean>;
+    readonly subscribedId: Schema.optionalKey<Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>>;
+    readonly paymentStatus: Schema.optionalKey<Schema.Literals<readonly ["free", "active", "past_due", "unpaid", "canceled", "incomplete"]>>;
+}>;
+export type Plan = typeof Plan.Type;
+/** A card on file. */
+export declare const CardPaymentMethod: Schema.TaggedStruct<"card", {
+    readonly brand: Schema.String;
+    readonly lastFour: Schema.String;
+    readonly expiryMonth: Schema.Int;
+    readonly expiryYear: Schema.Int;
+}>;
+/**
+ * A Link account on file. Stripe reports only the account's email, which is null when Link holds
+ * none, and nothing about the card behind it.
+ */
+export declare const LinkPaymentMethod: Schema.TaggedStruct<"link", {
+    readonly email: Schema.NullOr<Schema.String>;
+}>;
+export declare const PaymentMethod: Schema.Union<readonly [Schema.TaggedStruct<"card", {
+    readonly brand: Schema.String;
+    readonly lastFour: Schema.String;
+    readonly expiryMonth: Schema.Int;
+    readonly expiryYear: Schema.Int;
+}>, Schema.TaggedStruct<"link", {
+    readonly email: Schema.NullOr<Schema.String>;
+}>]>;
+export type PaymentMethod = typeof PaymentMethod.Type;
+export declare const SpendLimit: Schema.Struct<{
+    readonly limitCents: Schema.NullOr<Schema.Int>;
+    readonly currentSpendCents: Schema.Int;
+}>;
+export type SpendLimit = typeof SpendLimit.Type;
+/**
+ * One cap as the edge's admission decides it now, whatever period is being
+ * reported, discriminated by `cap`. `limit` is null when the cap does not
+ * apply. `atCap` means usage has reached the limit; `refusing` means the edge
+ * would refuse the next new command, or for `connections` the next new
+ * connection, or for `storage` that the organization's managed databases are
+ * read-only: writes fail and reads still work. `reason` is `unbound` when the
+ * edge refuses everything because the organization has no billing account;
+ * such caps have no limit.
+ *
+ * `limit` and `used` are cents for `spend`, open connections for
+ * `connections`, compute unit-hours used in the current billing period for
+ * `compute`, and decimal gigabytes for `storage`: the organization's pooled
+ * managed database storage, where `used` is the latest pooled sample. A
+ * database the customer brings never counts toward it.
+ */
+export declare const CapState: Schema.Struct<{
+    readonly limit: Schema.NullOr<Schema.Finite>;
+    readonly used: Schema.Finite;
+    readonly atCap: Schema.Boolean;
+    readonly refusing: Schema.Boolean;
+    readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
+    readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+}>;
+export type CapState = typeof CapState.Type;
+/**
+ * `plan` is `unbound` when the organization has no billing account: it has no
+ * plan, price or allowances, and is never reported as Free. Its spend limit is
+ * then null and its current spend zero, since the edge admits nothing for it.
+ */
+export declare const BillingSummary: Schema.Struct<{
+    readonly plan: Schema.Union<readonly [Schema.TaggedStruct<"known", {
+        readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        readonly name: Schema.String;
+        readonly basePriceCents: Schema.Int;
+        readonly currency: Schema.Literal<"usd">;
+        readonly renewsAt: Schema.NullOr<Schema.DateTimeUtc>;
+        readonly monthToDateEstimateCents: Schema.Int;
+        readonly provisional: Schema.optionalKey<Schema.Boolean>;
+        readonly subscribedId: Schema.optionalKey<Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>>;
+        readonly paymentStatus: Schema.optionalKey<Schema.Literals<readonly ["free", "active", "past_due", "unpaid", "canceled", "incomplete"]>>;
+    }>, Schema.TaggedStruct<"unbound", {}>]>;
+    readonly paymentMethod: Schema.NullOr<Schema.Union<readonly [Schema.TaggedStruct<"card", {
+        readonly brand: Schema.String;
+        readonly lastFour: Schema.String;
+        readonly expiryMonth: Schema.Int;
+        readonly expiryYear: Schema.Int;
+    }>, Schema.TaggedStruct<"link", {
+        readonly email: Schema.NullOr<Schema.String>;
+    }>]>>;
+    readonly billingEmail: Schema.NullOr<Schema.brand<Schema.String, "Email">>;
+    readonly spendLimit: Schema.Struct<{
+        readonly limitCents: Schema.NullOr<Schema.Int>;
+        readonly currentSpendCents: Schema.Int;
+    }>;
+    readonly caps: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly limit: Schema.NullOr<Schema.Finite>;
+        readonly used: Schema.Finite;
+        readonly atCap: Schema.Boolean;
+        readonly refusing: Schema.Boolean;
+        readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+    }>>>;
+}>;
+export type BillingSummary = typeof BillingSummary.Type;
+export declare const SetSpendLimit: Schema.Struct<{
+    readonly limitCents: Schema.NullOr<Schema.Int>;
+}>;
+export type SetSpendLimit = typeof SetSpendLimit.Type;
+export declare const Invoice: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InvoiceId">;
+    readonly number: Schema.String;
+    readonly periodStart: Schema.DateTimeUtc;
+    readonly periodEnd: Schema.DateTimeUtc;
+    readonly amountCents: Schema.Int;
+    readonly currency: Schema.Literal<"usd">;
+    readonly status: Schema.Literals<readonly ["draft", "open", "paid", "void", "uncollectible"]>;
+    readonly pdfUrl: Schema.NullOr<Schema.String>;
+}>;
+export type Invoice = typeof Invoice.Type;
+/** The paid plan to move to; the server builds the checkout and return URLs. */
+export declare const StartCheckout: Schema.Struct<{
+    readonly plan: Schema.Literals<readonly ["pro", "team", "enterprise"]>;
+}>;
+export type StartCheckout = typeof StartCheckout.Type;
+/** A plan change on the existing subscription; payment confirmation can leave it pending. */
+export declare const PlanChange: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly status: Schema.Literals<readonly ["pending", "completed", "failed"]>;
+}>;
+export type PlanChange = typeof PlanChange.Type;
+/** A hosted Stripe page the browser should navigate to. */
+export declare const HostedSession: Schema.Struct<{
+    readonly url: Schema.String;
+}>;
+export type HostedSession = typeof HostedSession.Type;
+/**
+ * What a plan offers, derived from the pricing configuration: billed compute
+ * overage, a hard compute cap, billed storage overage, a hard storage cap, a
+ * database the customer brings, a dedicated database, and a paid subscription
+ * bought through checkout.
+ */
+export declare const PlanFeature: Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>;
+export type PlanFeature = typeof PlanFeature.Type;
+/**
+ * One tier of the pricing configuration. `allowances.computeUnitHours` is the
+ * included compute unit-hours and `allowances.computeUnitHourCap` its hard
+ * stop (null when overage is billed instead at
+ * `overage.computeCentsPerUnitHour`). A machine size's hour bills the compute
+ * unit-hours `PlanCatalog.computeSizes` gives it.
+ *
+ * `allowances.storageGb` is the managed database storage included in the
+ * plan, in decimal gigabytes, pooled across the organization's managed
+ * environment databases. `allowances.storageGbCap` is its hard stop, past
+ * which those databases are read-only, and is null when overage is billed
+ * instead at `overage.storageCentsPerGbMonth`. A provisional tier's prices
+ * are not yet published.
+ */
+export declare const CatalogPlan: Schema.Struct<{
+    readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+    readonly name: Schema.String;
+    readonly basePriceCents: Schema.Int;
+    readonly currency: Schema.Literal<"usd">;
+    readonly allowances: Schema.Struct<{
+        readonly computeUnitHours: Schema.Finite;
+        readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
+        readonly storageGb: Schema.Finite;
+        readonly storageGbCap: Schema.NullOr<Schema.Finite>;
+        readonly concurrentConnections: Schema.Int;
+    }>;
+    readonly overage: Schema.Struct<{
+        readonly computeCentsPerUnitHour: Schema.Finite;
+        readonly storageCentsPerGbMonth: Schema.Finite;
+    }>;
+    readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+    readonly provisional: Schema.Boolean;
+}>;
+export type CatalogPlan = typeof CatalogPlan.Type;
+/**
+ * One machine size's weight in compute units: an hour of the size bills
+ * `unitsPerHour` compute unit-hours. The weights come from the pricing
+ * configuration.
+ */
+export declare const ComputeSize: Schema.Struct<{
+    readonly cpuKind: Schema.Literals<readonly ["shared", "performance"]>;
+    readonly cpus: Schema.Int;
+    readonly memoryMb: Schema.Int;
+    readonly unitsPerHour: Schema.Finite;
+}>;
+export type ComputeSize = typeof ComputeSize.Type;
+/**
+ * Every plan, cheapest first; `provisional` is true while any plan's prices
+ * are provisional. `computeSizes` lists the compute unit weight of every
+ * machine size the platform runs.
+ */
+export declare const PlanCatalog: Schema.Struct<{
+    readonly plans: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
+        readonly name: Schema.String;
+        readonly basePriceCents: Schema.Int;
+        readonly currency: Schema.Literal<"usd">;
+        readonly allowances: Schema.Struct<{
+            readonly computeUnitHours: Schema.Finite;
+            readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
+            readonly storageGb: Schema.Finite;
+            readonly storageGbCap: Schema.NullOr<Schema.Finite>;
+            readonly concurrentConnections: Schema.Int;
+        }>;
+        readonly overage: Schema.Struct<{
+            readonly computeCentsPerUnitHour: Schema.Finite;
+            readonly storageCentsPerGbMonth: Schema.Finite;
+        }>;
+        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+        readonly provisional: Schema.Boolean;
+    }>>;
+    readonly computeSizes: Schema.$Array<Schema.Struct<{
+        readonly cpuKind: Schema.Literals<readonly ["shared", "performance"]>;
+        readonly cpus: Schema.Int;
+        readonly memoryMb: Schema.Int;
+        readonly unitsPerHour: Schema.Finite;
+    }>>;
+    readonly provisional: Schema.Boolean;
+}>;
+export type PlanCatalog = typeof PlanCatalog.Type;
+/**
+ * `runnerHours` is measured in compute unit-hours (see `ComputeUsage`), not
+ * machine hours; raw machine hours are reported per machine size in
+ * `ComputeUsage.machineHours`. `storageGb` is the average pooled managed
+ * database storage over the period in decimal gigabytes, billed per GB-month.
+ */
+export declare const UsageMeterName: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+export type UsageMeterName = typeof UsageMeterName.Type;
+export declare const UsageMeter: Schema.Struct<{
+    readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+    readonly used: Schema.Finite;
+    readonly included: Schema.Finite;
+    readonly overage: Schema.Finite;
+    readonly overageCostCents: Schema.Finite;
+}>;
+export type UsageMeter = typeof UsageMeter.Type;
+/**
+ * The published rules usage is priced by, sent with every usage report.
+ * `computeCentsPerUnitHour` prices compute unit-hours beyond the plan's
+ * allowance and `storageCentsPerGbMonth` prices managed database storage
+ * beyond it; each is 0 where the plan bills no overage.
+ */
+export declare const UsagePricing: Schema.Struct<{
+    readonly computeCentsPerUnitHour: Schema.Finite;
+    readonly storageCentsPerGbMonth: Schema.Finite;
+    readonly provisional: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type UsagePricing = typeof UsagePricing.Type;
+/**
+ * Compute used by one machine size in one environment during the period:
+ * `machineHours` raw machine hours, billed as `computeUnitHours` at the
+ * size's `ComputeSize.unitsPerHour` in the plan catalog.
+ */
+export declare const ComputeUsage: Schema.Struct<{
+    readonly cpuKind: Schema.Literals<readonly ["shared", "performance"]>;
+    readonly cpus: Schema.Int;
+    readonly memoryMb: Schema.Int;
+    readonly environmentId: Schema.brand<Schema.String, "EnvironmentId">;
+    readonly machineHours: Schema.Finite;
+    readonly computeUnitHours: Schema.Finite;
+}>;
+export type ComputeUsage = typeof ComputeUsage.Type;
+/**
+ * The organization's latest pooled managed database storage: the sum of the
+ * sampled bytes of its managed environment databases, and when it was
+ * sampled. A database the customer brings is excluded.
+ */
+export declare const StorageSample: Schema.Struct<{
+    readonly bytes: Schema.Finite;
+    readonly sampledAt: Schema.DateTimeUtc;
+}>;
+export type StorageSample = typeof StorageSample.Type;
+/**
+ * `caps` describe now whatever `period` is reported. A project's
+ * `computeUnitHours` is its compute for the period and `compute` breaks it
+ * down by environment and machine size; its `storageGbMonths` is its managed
+ * databases' storage for the period.
+ */
+export declare const Usage: Schema.Struct<{
+    readonly period: Schema.String;
+    readonly meters: Schema.$Array<Schema.Struct<{
+        readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+        readonly used: Schema.Finite;
+        readonly included: Schema.Finite;
+        readonly overage: Schema.Finite;
+        readonly overageCostCents: Schema.Finite;
+    }>>;
+    readonly latestStorageSample: Schema.NullOr<Schema.Struct<{
+        readonly bytes: Schema.Finite;
+        readonly sampledAt: Schema.DateTimeUtc;
+    }>>;
+    readonly caps: Schema.$Array<Schema.Struct<{
+        readonly limit: Schema.NullOr<Schema.Finite>;
+        readonly used: Schema.Finite;
+        readonly atCap: Schema.Boolean;
+        readonly refusing: Schema.Boolean;
+        readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+    }>>;
+    readonly byProject: Schema.$Array<Schema.Struct<{
+        readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+        readonly name: Schema.String;
+        readonly computeUnitHours: Schema.Finite;
+        readonly compute: Schema.$Array<Schema.Struct<{
+            readonly cpuKind: Schema.Literals<readonly ["shared", "performance"]>;
+            readonly cpus: Schema.Int;
+            readonly memoryMb: Schema.Int;
+            readonly environmentId: Schema.brand<Schema.String, "EnvironmentId">;
+            readonly machineHours: Schema.Finite;
+            readonly computeUnitHours: Schema.Finite;
+        }>>;
+        readonly storageGbMonths: Schema.Finite;
+        readonly estimatedCostCents: Schema.Finite;
+    }>>;
+    readonly pricing: Schema.Struct<{
+        readonly computeCentsPerUnitHour: Schema.Finite;
+        readonly storageCentsPerGbMonth: Schema.Finite;
+        readonly provisional: Schema.optionalKey<Schema.Boolean>;
+    }>;
+}>;
+export type Usage = typeof Usage.Type;
+export declare const AuditEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly at: Schema.DateTimeUtc;
+    readonly actor: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["user", "api-key"]>;
+        readonly id: Schema.String;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>;
+    readonly action: Schema.String;
+    readonly target: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.NullOr<Schema.String>;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>;
+    readonly ipAddress: Schema.NullOr<Schema.String>;
+}>;
+export type AuditEntry = typeof AuditEntry.Type;