@distilled.cloud/fly-io 0.30.2 → 1.0.0-rc.1

package/src/operations/MachinesUpdateMetadata.ts

@@ -1,47 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest } from "../errors.ts";
-
-// Input Schema
-export interface MachinesUpdateMetadataInput {
-  app_name: string;
-  machine_id: string;
-  machine_version?: string;
-  metadata?: Record<string, string>;
-  updated_at?: string;
-}
-export const MachinesUpdateMetadataInput =
-  /*@__PURE__*/ Schema.Struct({
-    app_name: Schema.String.pipe(T.PathParam()),
-    machine_id: Schema.String.pipe(T.PathParam()),
-    machine_version: Schema.optional(Schema.String),
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-    updated_at: Schema.optional(Schema.String),
-  }).pipe(
-    T.Http({
-      method: "PATCH",
-      path: "/apps/{app_name}/machines/{machine_id}/metadata",
-    }),
-  ) as unknown as Schema.Codec<MachinesUpdateMetadataInput>;
-
-// Output Schema
-export type MachinesUpdateMetadataOutput = void;
-export const MachinesUpdateMetadataOutput =
-  /*@__PURE__*/ Schema.Void as unknown as Schema.Codec<MachinesUpdateMetadataOutput>;
-
-// The operation
-/**
- * Update Metadata (set/remove multiple keys)
- *
- * Update multiple metadata keys at once. Null values and empty strings remove keys.
- * + If `machine_version` is provided and no longer matches the current machine version, returns 412 Precondition Failed.
- *
- * @param app_name - Fly App Name
- * @param machine_id - Machine ID
- */
-export const MachinesUpdateMetadata = /*@__PURE__*/ API.make(() => ({
-  inputSchema: MachinesUpdateMetadataInput,
-  outputSchema: MachinesUpdateMetadataOutput,
-  errors: [BadRequest] as const,
-}));

package/src/operations/MachinesUpsertMetadata.ts

@@ -1,47 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface MachinesUpsertMetadataInput {
-  app_name: string;
-  machine_id: string;
-  key: string;
-  updated_at?: string;
-  value?: string;
-}
-export const MachinesUpsertMetadataInput =
-  /*@__PURE__*/ Schema.Struct({
-    app_name: Schema.String.pipe(T.PathParam()),
-    machine_id: Schema.String.pipe(T.PathParam()),
-    key: Schema.String.pipe(T.PathParam()),
-    updated_at: Schema.optional(Schema.String),
-    value: Schema.optional(Schema.String),
-  }).pipe(
-    T.Http({
-      method: "POST",
-      path: "/apps/{app_name}/machines/{machine_id}/metadata/{key}",
-    }),
-  ) as unknown as Schema.Codec<MachinesUpsertMetadataInput>;
-
-// Output Schema
-export type MachinesUpsertMetadataOutput = void;
-export const MachinesUpsertMetadataOutput =
-  /*@__PURE__*/ Schema.Void as unknown as Schema.Codec<MachinesUpsertMetadataOutput>;
-
-// The operation
-/**
- * Upsert Metadata Key
- *
- * Update metadata for a specific machine within an app by providing a metadata key.
- *
- * @param app_name - Fly App Name
- * @param machine_id - Machine ID
- * @param key - Metadata Key
- */
-export const MachinesUpsertMetadata = /*@__PURE__*/ API.make(() => ({
-  inputSchema: MachinesUpsertMetadataInput,
-  outputSchema: MachinesUpsertMetadataOutput,
-  errors: [BadRequest, Forbidden, NotFound] as const,
-}));

package/src/operations/MachinesWait.ts

@@ -1,79 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface MachinesWaitInput {
-  app_name: string;
-  machine_id: string;
-  version?: string;
-  instance_id?: string;
-  from_event_id?: string;
-  timeout?: number;
-  state?:
-    | "started"
-    | "stopped"
-    | "suspended"
-    | "destroyed"
-    | "failed"
-    | "settled";
-}
-export const MachinesWaitInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  machine_id: Schema.String.pipe(T.PathParam()),
-  version: Schema.optional(Schema.String),
-  instance_id: Schema.optional(Schema.String),
-  from_event_id: Schema.optional(Schema.String),
-  timeout: Schema.optional(Schema.Number),
-  state: Schema.optional(
-    Schema.Literals([
-      "started",
-      "stopped",
-      "suspended",
-      "destroyed",
-      "failed",
-      "settled",
-    ]),
-  ),
-}).pipe(
-  T.Http({
-    method: "GET",
-    path: "/apps/{app_name}/machines/{machine_id}/wait",
-  }),
-) as unknown as Schema.Codec<MachinesWaitInput>;
-
-// Output Schema
-export interface MachinesWaitOutput {
-  event_id?: string;
-  ok?: boolean;
-  state?: string;
-  version?: string;
-}
-export const MachinesWaitOutput = /*@__PURE__*/ Schema.Struct({
-  event_id: Schema.optional(Schema.String),
-  ok: Schema.optional(Schema.Boolean),
-  state: Schema.optional(Schema.String),
-  version: Schema.optional(Schema.String),
-}) as unknown as Schema.Codec<MachinesWaitOutput>;
-
-// The operation
-/**
- * Wait for State
- *
- * Wait for a Machine to reach a specific state. Specify the desired state with the state parameter. See the [Machine states table](https://fly.io/docs/machines/working-with-machines/#machine-states) for a list of possible states. The default for this parameter is `started`.
- * This request will block for up to 60 seconds. Set a shorter timeout with the timeout parameter.
- *
- * @param app_name - Fly App Name
- * @param machine_id - Machine ID
- * @param version - 26-character Machine version ID
- * @param instance_id - 26-character Machine version ID (deprecated; use version)
- * @param from_event_id - 26-character Machine event ID to start waiting after
- * @param timeout - wait timeout. default 60s
- * @param state - desired state(s), supports repeated or comma-separated values
- */
-export const MachinesWait = /*@__PURE__*/ API.make(() => ({
-  inputSchema: MachinesWaitInput,
-  outputSchema: MachinesWaitOutput,
-  errors: [BadRequest, Forbidden, NotFound] as const,
-}));

package/src/operations/PlatformPlacementsPost.ts

@@ -1,80 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden } from "../errors.ts";
-
-// Input Schema
-export interface PlatformPlacementsPostInput {
-  compute?: {
-    cpu_kind?: string;
-    cpus?: number;
-    gpu_kind?: string;
-    gpus?: number;
-    host_dedication_id?: string;
-    kernel_args?: string[];
-    max_memory_mb?: number;
-    memory_mb?: number;
-    persist_rootfs?: "never" | "always" | "restart";
-  };
-  count?: number;
-  org_slug: string;
-  region?: string;
-  volume_name?: string;
-  volume_size_bytes?: number;
-  weights?: Record<string, number>;
-}
-export const PlatformPlacementsPostInput =
-  /*@__PURE__*/ Schema.Struct({
-    compute: Schema.optional(
-      Schema.Struct({
-        cpu_kind: Schema.optional(Schema.String),
-        cpus: Schema.optional(Schema.Number),
-        gpu_kind: Schema.optional(Schema.String),
-        gpus: Schema.optional(Schema.Number),
-        host_dedication_id: Schema.optional(Schema.String),
-        kernel_args: Schema.optional(Schema.Array(Schema.String)),
-        max_memory_mb: Schema.optional(Schema.Number),
-        memory_mb: Schema.optional(Schema.Number),
-        persist_rootfs: Schema.optional(
-          Schema.Literals(["never", "always", "restart"]),
-        ),
-      }),
-    ),
-    count: Schema.optional(Schema.Number),
-    org_slug: Schema.String,
-    region: Schema.optional(Schema.String),
-    volume_name: Schema.optional(Schema.String),
-    volume_size_bytes: Schema.optional(Schema.Number),
-    weights: Schema.optional(Schema.Record(Schema.String, Schema.Number)),
-  }).pipe(
-    T.Http({ method: "POST", path: "/platform/placements" }),
-  ) as unknown as Schema.Codec<PlatformPlacementsPostInput>;
-
-// Output Schema
-export interface PlatformPlacementsPostOutput {
-  regions?: { concurrency?: number; count?: number; region?: string }[];
-}
-export const PlatformPlacementsPostOutput =
-  /*@__PURE__*/ Schema.Struct({
-    regions: Schema.optional(
-      Schema.Array(
-        Schema.Struct({
-          concurrency: Schema.optional(Schema.Number),
-          count: Schema.optional(Schema.Number),
-          region: Schema.optional(Schema.String),
-        }),
-      ),
-    ),
-  }) as unknown as Schema.Codec<PlatformPlacementsPostOutput>;
-
-// The operation
-/**
- * Get Placements
- *
- * Simulates placing the specified number of machines into regions, depending on available capacity and limits.
- */
-export const PlatformPlacementsPost = /*@__PURE__*/ API.make(() => ({
-  inputSchema: PlatformPlacementsPostInput,
-  outputSchema: PlatformPlacementsPostOutput,
-  errors: [BadRequest, Forbidden] as const,
-}));

package/src/operations/PlatformRegionsGet.ts

@@ -1,56 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { Forbidden } from "../errors.ts";
-
-// Input Schema
-export interface PlatformRegionsGetInput {}
-export const PlatformRegionsGetInput =
-  /*@__PURE__*/ Schema.Struct({}).pipe(
-    T.Http({ method: "GET", path: "/platform/regions" }),
-  ) as unknown as Schema.Codec<PlatformRegionsGetInput>;
-
-// Output Schema
-export interface PlatformRegionsGetOutput {
-  nearest?: string;
-  regions?: {
-    code?: string;
-    deprecated?: boolean;
-    gateway_available?: boolean;
-    geo_region?: string;
-    latitude?: number;
-    longitude?: number;
-    name?: string;
-    requires_paid_plan?: boolean;
-  }[];
-}
-export const PlatformRegionsGetOutput =
-  /*@__PURE__*/ Schema.Struct({
-    nearest: Schema.optional(Schema.String),
-    regions: Schema.optional(
-      Schema.Array(
-        Schema.Struct({
-          code: Schema.optional(Schema.String),
-          deprecated: Schema.optional(Schema.Boolean),
-          gateway_available: Schema.optional(Schema.Boolean),
-          geo_region: Schema.optional(Schema.String),
-          latitude: Schema.optional(Schema.Number),
-          longitude: Schema.optional(Schema.Number),
-          name: Schema.optional(Schema.String),
-          requires_paid_plan: Schema.optional(Schema.Boolean),
-        }),
-      ),
-    ),
-  }) as unknown as Schema.Codec<PlatformRegionsGetOutput>;
-
-// The operation
-/**
- * Get Regions
- *
- * List all regions on the platform with their details.
- */
-export const PlatformRegionsGet = /*@__PURE__*/ API.make(() => ({
-  inputSchema: PlatformRegionsGetInput,
-  outputSchema: PlatformRegionsGetOutput,
-  errors: [Forbidden] as const,
-}));

package/src/operations/SecretCreate.ts

@@ -1,51 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretCreateInput {
-  app_name: string;
-  secret_name: string;
-  value?: string;
-}
-export const SecretCreateInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-  value: Schema.optional(Schema.String),
-}).pipe(
-  T.Http({ method: "POST", path: "/apps/{app_name}/secrets/{secret_name}" }),
-) as unknown as Schema.Codec<SecretCreateInput>;
-
-// Output Schema
-export interface SecretCreateOutput {
-  Version?: number;
-  created_at?: string;
-  digest?: string;
-  name?: string;
-  updated_at?: string;
-  value?: string;
-  version?: number;
-}
-export const SecretCreateOutput = /*@__PURE__*/ Schema.Struct({
-  Version: Schema.optional(Schema.Number),
-  created_at: Schema.optional(Schema.String),
-  digest: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  updated_at: Schema.optional(Schema.String),
-  value: Schema.optional(Schema.String),
-  version: Schema.optional(Schema.Number),
-}) as unknown as Schema.Codec<SecretCreateOutput>;
-
-// The operation
-/**
- * Create or update Secret
- *
- * @param app_name - Fly App Name
- * @param secret_name - App secret name
- */
-export const SecretCreate = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretCreateInput,
-  outputSchema: SecretCreateOutput,
-  errors: [BadRequest, Forbidden, NotFound] as const,
-}));

package/src/operations/SecretDelete.ts

@@ -1,39 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretDeleteInput {
-  app_name: string;
-  secret_name: string;
-}
-export const SecretDeleteInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "DELETE", path: "/apps/{app_name}/secrets/{secret_name}" }),
-) as unknown as Schema.Codec<SecretDeleteInput>;
-
-// Output Schema
-export interface SecretDeleteOutput {
-  Version?: number;
-  version?: number;
-}
-export const SecretDeleteOutput = /*@__PURE__*/ Schema.Struct({
-  Version: Schema.optional(Schema.Number),
-  version: Schema.optional(Schema.Number),
-}) as unknown as Schema.Codec<SecretDeleteOutput>;
-
-// The operation
-/**
- * Delete an app secret
- *
- * @param app_name - Fly App Name
- * @param secret_name - App secret name
- */
-export const SecretDelete = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretDeleteInput,
-  outputSchema: SecretDeleteOutput,
-  errors: [Forbidden, NotFound] as const,
-}));

package/src/operations/SecretGet.ts

@@ -1,51 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretGetInput {
-  app_name: string;
-  secret_name: string;
-  min_version?: string;
-  show_secrets?: boolean;
-}
-export const SecretGetInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-  min_version: Schema.optional(Schema.String),
-  show_secrets: Schema.optional(Schema.Boolean),
-}).pipe(
-  T.Http({ method: "GET", path: "/apps/{app_name}/secrets/{secret_name}" }),
-) as unknown as Schema.Codec<SecretGetInput>;
-
-// Output Schema
-export interface SecretGetOutput {
-  created_at?: string;
-  digest?: string;
-  name?: string;
-  updated_at?: string;
-  value?: string;
-}
-export const SecretGetOutput = /*@__PURE__*/ Schema.Struct({
-  created_at: Schema.optional(Schema.String),
-  digest: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  updated_at: Schema.optional(Schema.String),
-  value: Schema.optional(Schema.String),
-}) as unknown as Schema.Codec<SecretGetOutput>;
-
-// The operation
-/**
- * Get an app secret
- *
- * @param app_name - Fly App Name
- * @param secret_name - App secret name
- * @param min_version - Minimum secrets version to return. Returned when setting a new secret
- * @param show_secrets - Show the secret value.
- */
-export const SecretGet = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretGetInput,
-  outputSchema: SecretGetOutput,
-  errors: [Forbidden, NotFound] as const,
-}));

package/src/operations/SecretkeyDecrypt.ts

@@ -1,47 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretkeyDecryptInput {
-  app_name: string;
-  secret_name: string;
-  min_version?: string;
-  associated_data?: number[];
-  ciphertext?: number[];
-}
-export const SecretkeyDecryptInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-  min_version: Schema.optional(Schema.String),
-  associated_data: Schema.optional(Schema.Array(Schema.Number)),
-  ciphertext: Schema.optional(Schema.Array(Schema.Number)),
-}).pipe(
-  T.Http({
-    method: "POST",
-    path: "/apps/{app_name}/secretkeys/{secret_name}/decrypt",
-  }),
-) as unknown as Schema.Codec<SecretkeyDecryptInput>;
-
-// Output Schema
-export interface SecretkeyDecryptOutput {
-  plaintext?: number[];
-}
-export const SecretkeyDecryptOutput = /*@__PURE__*/ Schema.Struct({
-  plaintext: Schema.optional(Schema.Array(Schema.Number)),
-}) as unknown as Schema.Codec<SecretkeyDecryptOutput>;
-
-// The operation
-/**
- * Decrypt with a secret key
- *
- * @param app_name - Fly App Name
- * @param secret_name - Secret key name
- * @param min_version - Minimum secrets version to return. Returned when setting a new secret
- */
-export const SecretkeyDecrypt = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretkeyDecryptInput,
-  outputSchema: SecretkeyDecryptOutput,
-  errors: [BadRequest, Forbidden, NotFound] as const,
-}));

package/src/operations/SecretkeyDelete.ts

@@ -1,42 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretkeyDeleteInput {
-  app_name: string;
-  secret_name: string;
-}
-export const SecretkeyDeleteInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({
-    method: "DELETE",
-    path: "/apps/{app_name}/secretkeys/{secret_name}",
-  }),
-) as unknown as Schema.Codec<SecretkeyDeleteInput>;
-
-// Output Schema
-export interface SecretkeyDeleteOutput {
-  Version?: number;
-  version?: number;
-}
-export const SecretkeyDeleteOutput = /*@__PURE__*/ Schema.Struct({
-  Version: Schema.optional(Schema.Number),
-  version: Schema.optional(Schema.Number),
-}) as unknown as Schema.Codec<SecretkeyDeleteOutput>;
-
-// The operation
-/**
- * Delete an app's secret key
- *
- * @param app_name - Fly App Name
- * @param secret_name - Secret key name
- */
-export const SecretkeyDelete = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretkeyDeleteInput,
-  outputSchema: SecretkeyDeleteOutput,
-  errors: [Forbidden, NotFound] as const,
-}));

package/src/operations/SecretkeyEncrypt.ts

@@ -1,47 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretkeyEncryptInput {
-  app_name: string;
-  secret_name: string;
-  min_version?: string;
-  associated_data?: number[];
-  plaintext?: number[];
-}
-export const SecretkeyEncryptInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-  min_version: Schema.optional(Schema.String),
-  associated_data: Schema.optional(Schema.Array(Schema.Number)),
-  plaintext: Schema.optional(Schema.Array(Schema.Number)),
-}).pipe(
-  T.Http({
-    method: "POST",
-    path: "/apps/{app_name}/secretkeys/{secret_name}/encrypt",
-  }),
-) as unknown as Schema.Codec<SecretkeyEncryptInput>;
-
-// Output Schema
-export interface SecretkeyEncryptOutput {
-  ciphertext?: number[];
-}
-export const SecretkeyEncryptOutput = /*@__PURE__*/ Schema.Struct({
-  ciphertext: Schema.optional(Schema.Array(Schema.Number)),
-}) as unknown as Schema.Codec<SecretkeyEncryptOutput>;
-
-// The operation
-/**
- * Encrypt with a secret key
- *
- * @param app_name - Fly App Name
- * @param secret_name - Secret key name
- * @param min_version - Minimum secrets version to return. Returned when setting a new secret
- */
-export const SecretkeyEncrypt = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretkeyEncryptInput,
-  outputSchema: SecretkeyEncryptOutput,
-  errors: [BadRequest, Forbidden, NotFound] as const,
-}));

package/src/operations/SecretkeyGenerate.ts

@@ -1,57 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface SecretkeyGenerateInput {
-  app_name: string;
-  secret_name: string;
-  type?: string;
-  value?: number[];
-}
-export const SecretkeyGenerateInput = /*@__PURE__*/ Schema.Struct({
-  app_name: Schema.String.pipe(T.PathParam()),
-  secret_name: Schema.String.pipe(T.PathParam()),
-  type: Schema.optional(Schema.String),
-  value: Schema.optional(Schema.Array(Schema.Number)),
-}).pipe(
-  T.Http({
-    method: "POST",
-    path: "/apps/{app_name}/secretkeys/{secret_name}/generate",
-  }),
-) as unknown as Schema.Codec<SecretkeyGenerateInput>;
-
-// Output Schema
-export interface SecretkeyGenerateOutput {
-  Version?: number;
-  created_at?: string;
-  name?: string;
-  public_key?: number[];
-  type?: string;
-  updated_at?: string;
-  version?: number;
-}
-export const SecretkeyGenerateOutput =
-  /*@__PURE__*/ Schema.Struct({
-    Version: Schema.optional(Schema.Number),
-    created_at: Schema.optional(Schema.String),
-    name: Schema.optional(Schema.String),
-    public_key: Schema.optional(Schema.Array(Schema.Number)),
-    type: Schema.optional(Schema.String),
-    updated_at: Schema.optional(Schema.String),
-    version: Schema.optional(Schema.Number),
-  }) as unknown as Schema.Codec<SecretkeyGenerateOutput>;
-
-// The operation
-/**
- * Generate a random secret key
- *
- * @param app_name - Fly App Name
- * @param secret_name - Secret key name
- */
-export const SecretkeyGenerate = /*@__PURE__*/ API.make(() => ({
-  inputSchema: SecretkeyGenerateInput,
-  outputSchema: SecretkeyGenerateOutput,
-  errors: [BadRequest, Forbidden, NotFound] as const,
-}));