@distilled.cloud/fly-io 0.26.1 → 0.28.0

package/src/operations/SecretsList.ts

@@ -4,14 +4,29 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretsListInput {
+  app_name: string;
+  min_version?: string;
+  show_secrets?: boolean;
+}
 export const SecretsListInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_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" }));
-export type SecretsListInput = typeof SecretsListInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/apps/{app_name}/secrets" }),
+) as unknown as Schema.Codec<SecretsListInput>;
 
 // Output Schema
+export interface SecretsListOutput {
+  secrets?: {
+    created_at?: string;
+    digest?: string;
+    name?: string;
+    updated_at?: string;
+    value?: string;
+  }[];
+}
 export const SecretsListOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   secrets: Schema.optional(
     Schema.Array(
@@ -24,8 +39,7 @@ export const SecretsListOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       }),
     ),
   ),
-});
-export type SecretsListOutput = typeof SecretsListOutput.Type;
+}) as unknown as Schema.Codec<SecretsListOutput>;
 
 // The operation
 /**

package/src/operations/SecretsUpdate.ts

@@ -4,13 +4,29 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretsUpdateInput {
+  app_name: string;
+  values?: Record<string, string>;
+}
 export const SecretsUpdateInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   values: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}).pipe(T.Http({ method: "POST", path: "/apps/{app_name}/secrets" }));
-export type SecretsUpdateInput = typeof SecretsUpdateInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/apps/{app_name}/secrets" }),
+) as unknown as Schema.Codec<SecretsUpdateInput>;
 
 // Output Schema
+export interface SecretsUpdateOutput {
+  Version?: number;
+  secrets?: {
+    created_at?: string;
+    digest?: string;
+    name?: string;
+    updated_at?: string;
+    value?: string;
+  }[];
+  version?: number;
+}
 export const SecretsUpdateOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   Version: Schema.optional(Schema.Number),
   secrets: Schema.optional(
@@ -25,8 +41,7 @@ export const SecretsUpdateOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     ),
   ),
   version: Schema.optional(Schema.Number),
-});
-export type SecretsUpdateOutput = typeof SecretsUpdateOutput.Type;
+}) as unknown as Schema.Codec<SecretsUpdateOutput>;
 
 // The operation
 /**

package/src/operations/TokensAuthenticate.ts

@@ -0,0 +1,54 @@
+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 TokensAuthenticateInput {
+  header?: string;
+}
+export const TokensAuthenticateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    header: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({ method: "POST", path: "/tokens/authenticate" }),
+  ) as unknown as Schema.Codec<TokensAuthenticateInput>;
+
+// Output Schema
+export type TokensAuthenticateOutput = {
+  caveats?: { caveats?: unknown[] };
+  header?: string;
+  nonce?: { kid?: number[]; proof?: boolean; rnd?: number[] };
+  permission_token?: number[];
+}[];
+export const TokensAuthenticateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+    Schema.Struct({
+      caveats: Schema.optional(
+        Schema.Struct({
+          caveats: Schema.optional(Schema.Array(Schema.Unknown)),
+        }),
+      ),
+      header: Schema.optional(Schema.String),
+      nonce: Schema.optional(
+        Schema.Struct({
+          kid: Schema.optional(Schema.Array(Schema.Number)),
+          proof: Schema.optional(Schema.Boolean),
+          rnd: Schema.optional(Schema.Array(Schema.Number)),
+        }),
+      ),
+      permission_token: Schema.optional(Schema.Array(Schema.Number)),
+    }),
+  ) as unknown as Schema.Codec<TokensAuthenticateOutput>;
+
+// The operation
+/**
+ * Authenticate token header
+ *
+ * Verify a token header without checking resource access.
+ */
+export const TokensAuthenticate = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: TokensAuthenticateInput,
+  outputSchema: TokensAuthenticateOutput,
+  errors: [BadRequest] as const,
+}));

package/src/operations/TokensAuthorize.ts

@@ -0,0 +1,122 @@
+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 TokensAuthorizeInput {
+  access?: {
+    action?: 1 | 2 | 4 | 8 | 16 | 31 | 0;
+    app_feature?: string;
+    app_name?: string;
+    command?: string[];
+    machine_feature?: string;
+    machine_id?: string;
+    mutation?: string;
+    org_feature?: string;
+    org_slug?: string;
+    source_machine?: string;
+    storage_object?: string;
+    volume_id?: string;
+  };
+  header?: string;
+}
+export const TokensAuthorizeInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  access: Schema.optional(
+    Schema.Struct({
+      action: Schema.optional(Schema.Literals([1, 2, 4, 8, 16, 31, 0])),
+      app_feature: Schema.optional(Schema.String),
+      app_name: Schema.optional(Schema.String),
+      command: Schema.optional(Schema.Array(Schema.String)),
+      machine_feature: Schema.optional(Schema.String),
+      machine_id: Schema.optional(Schema.String),
+      mutation: Schema.optional(Schema.String),
+      org_feature: Schema.optional(Schema.String),
+      org_slug: Schema.optional(Schema.String),
+      source_machine: Schema.optional(Schema.String),
+      storage_object: Schema.optional(Schema.String),
+      volume_id: Schema.optional(Schema.String),
+    }),
+  ),
+  header: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({ method: "POST", path: "/tokens/authorize" }),
+) as unknown as Schema.Codec<TokensAuthorizeInput>;
+
+// Output Schema
+export interface TokensAuthorizeOutput {
+  access?: {
+    action?: 1 | 2 | 4 | 8 | 16 | 31 | 0;
+    app_feature?: string;
+    appid?: number;
+    cluster?: string;
+    command?: string[];
+    feature?: string;
+    machine?: string;
+    machine_feature?: string;
+    mutation?: string;
+    orgid?: number;
+    sourceApp?: string;
+    sourceMachine?: string;
+    sourceOrganization?: string;
+    storage_object?: string;
+    volume?: string;
+  };
+  verified_token?: {
+    caveats?: { caveats?: unknown[] };
+    header?: string;
+    nonce?: { kid?: number[]; proof?: boolean; rnd?: number[] };
+    permission_token?: number[];
+  };
+}
+export const TokensAuthorizeOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  access: Schema.optional(
+    Schema.Struct({
+      action: Schema.optional(Schema.Literals([1, 2, 4, 8, 16, 31, 0])),
+      app_feature: Schema.optional(Schema.String),
+      appid: Schema.optional(Schema.Number),
+      cluster: Schema.optional(Schema.String),
+      command: Schema.optional(Schema.Array(Schema.String)),
+      feature: Schema.optional(Schema.String),
+      machine: Schema.optional(Schema.String),
+      machine_feature: Schema.optional(Schema.String),
+      mutation: Schema.optional(Schema.String),
+      orgid: Schema.optional(Schema.Number),
+      sourceApp: Schema.optional(Schema.String),
+      sourceMachine: Schema.optional(Schema.String),
+      sourceOrganization: Schema.optional(Schema.String),
+      storage_object: Schema.optional(Schema.String),
+      volume: Schema.optional(Schema.String),
+    }),
+  ),
+  verified_token: Schema.optional(
+    Schema.Struct({
+      caveats: Schema.optional(
+        Schema.Struct({
+          caveats: Schema.optional(Schema.Array(Schema.Unknown)),
+        }),
+      ),
+      header: Schema.optional(Schema.String),
+      nonce: Schema.optional(
+        Schema.Struct({
+          kid: Schema.optional(Schema.Array(Schema.Number)),
+          proof: Schema.optional(Schema.Boolean),
+          rnd: Schema.optional(Schema.Array(Schema.Number)),
+        }),
+      ),
+      permission_token: Schema.optional(Schema.Array(Schema.Number)),
+    }),
+  ),
+}) as unknown as Schema.Codec<TokensAuthorizeOutput>;
+
+// The operation
+/**
+ * Authorize token for resource access
+ *
+ * Verify a token header and validate it against a requested access scope.
+ */
+export const TokensAuthorize = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: TokensAuthorizeInput,
+  outputSchema: TokensAuthorizeOutput,
+  errors: [BadRequest] as const,
+}));

package/src/operations/TokensRequestKms.ts

@@ -4,14 +4,17 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface TokensRequestKmsInput {}
 export const TokensRequestKmsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {},
-).pipe(T.Http({ method: "POST", path: "/tokens/kms" }));
-export type TokensRequestKmsInput = typeof TokensRequestKmsInput.Type;
+).pipe(
+  T.Http({ method: "POST", path: "/tokens/kms" }),
+) as unknown as Schema.Codec<TokensRequestKmsInput>;
 
 // Output Schema
-export const TokensRequestKmsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.String;
-export type TokensRequestKmsOutput = typeof TokensRequestKmsOutput.Type;
+export type TokensRequestKmsOutput = void;
+export const TokensRequestKmsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<TokensRequestKmsOutput>;
 
 // The operation
 /**

package/src/operations/TokensRequestOIDC.ts

@@ -4,18 +4,23 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface TokensRequestOIDCInput {
+  aud?: string;
+  aws_principal_tags?: boolean;
+}
 export const TokensRequestOIDCInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     aud: Schema.optional(Schema.String),
     aws_principal_tags: Schema.optional(Schema.Boolean),
   },
-).pipe(T.Http({ method: "POST", path: "/tokens/oidc" }));
-export type TokensRequestOIDCInput = typeof TokensRequestOIDCInput.Type;
+).pipe(
+  T.Http({ method: "POST", path: "/tokens/oidc" }),
+) as unknown as Schema.Codec<TokensRequestOIDCInput>;
 
 // Output Schema
+export type TokensRequestOIDCOutput = void;
 export const TokensRequestOIDCOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.String;
-export type TokensRequestOIDCOutput = typeof TokensRequestOIDCOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<TokensRequestOIDCOutput>;
 
 // The operation
 /**

package/src/operations/VolumeDelete.ts

@@ -4,15 +4,41 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface VolumeDeleteInput {
+  app_name: string;
+  volume_id: string;
+}
 export const VolumeDeleteInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   volume_id: Schema.String.pipe(T.PathParam()),
 }).pipe(
   T.Http({ method: "DELETE", path: "/apps/{app_name}/volumes/{volume_id}" }),
-);
-export type VolumeDeleteInput = typeof VolumeDeleteInput.Type;
+) as unknown as Schema.Codec<VolumeDeleteInput>;
 
 // Output Schema
+export interface VolumeDeleteOutput {
+  attached_alloc_id?: string;
+  attached_machine_id?: string;
+  auto_backup_enabled?: boolean;
+  block_size?: number;
+  blocks?: number;
+  blocks_avail?: number;
+  blocks_free?: number;
+  bytes_total?: number;
+  bytes_used?: number;
+  created_at?: string;
+  encrypted?: boolean;
+  fstype?: string;
+  host_status?: "ok" | "unknown" | "unreachable";
+  id?: string;
+  name?: string;
+  region?: string;
+  size_gb?: number;
+  snapshot_retention?: number;
+  state?: string;
+  type?: "local" | "cache";
+  zone?: string;
+}
 export const VolumeDeleteOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   attached_alloc_id: Schema.optional(Schema.String),
   attached_machine_id: Schema.optional(Schema.String),
@@ -37,8 +63,7 @@ export const VolumeDeleteOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   state: Schema.optional(Schema.String),
   type: Schema.optional(Schema.Literals(["local", "cache"])),
   zone: Schema.optional(Schema.String),
-});
-export type VolumeDeleteOutput = typeof VolumeDeleteOutput.Type;
+}) as unknown as Schema.Codec<VolumeDeleteOutput>;
 
 // The operation
 /**

package/src/operations/VolumesCreate.ts

@@ -4,6 +4,32 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface VolumesCreateInput {
+  app_name: string;
+  auto_backup_enabled?: boolean;
+  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";
+  };
+  compute_image?: string;
+  encrypted?: boolean;
+  fstype?: string;
+  name?: string;
+  region?: string;
+  require_unique_zone?: boolean;
+  size_gb?: number;
+  snapshot_id?: string;
+  snapshot_retention?: number;
+  source_volume_id?: string;
+  unique_zone_app_wide?: boolean;
+}
 export const VolumesCreateInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   auto_backup_enabled: Schema.optional(Schema.Boolean),
@@ -33,10 +59,34 @@ export const VolumesCreateInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   snapshot_retention: Schema.optional(Schema.Number),
   source_volume_id: Schema.optional(Schema.String),
   unique_zone_app_wide: Schema.optional(Schema.Boolean),
-}).pipe(T.Http({ method: "POST", path: "/apps/{app_name}/volumes" }));
-export type VolumesCreateInput = typeof VolumesCreateInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/apps/{app_name}/volumes" }),
+) as unknown as Schema.Codec<VolumesCreateInput>;
 
 // Output Schema
+export interface VolumesCreateOutput {
+  attached_alloc_id?: string;
+  attached_machine_id?: string;
+  auto_backup_enabled?: boolean;
+  block_size?: number;
+  blocks?: number;
+  blocks_avail?: number;
+  blocks_free?: number;
+  bytes_total?: number;
+  bytes_used?: number;
+  created_at?: string;
+  encrypted?: boolean;
+  fstype?: string;
+  host_status?: "ok" | "unknown" | "unreachable";
+  id?: string;
+  name?: string;
+  region?: string;
+  size_gb?: number;
+  snapshot_retention?: number;
+  state?: string;
+  type?: "local" | "cache";
+  zone?: string;
+}
 export const VolumesCreateOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   attached_alloc_id: Schema.optional(Schema.String),
   attached_machine_id: Schema.optional(Schema.String),
@@ -61,8 +111,7 @@ export const VolumesCreateOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   state: Schema.optional(Schema.String),
   type: Schema.optional(Schema.Literals(["local", "cache"])),
   zone: Schema.optional(Schema.String),
-});
-export type VolumesCreateOutput = typeof VolumesCreateOutput.Type;
+}) as unknown as Schema.Codec<VolumesCreateOutput>;
 
 // The operation
 /**

package/src/operations/VolumesExtend.ts

@@ -4,6 +4,11 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface VolumesExtendInput {
+  app_name: string;
+  volume_id: string;
+  size_gb?: number;
+}
 export const VolumesExtendInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   volume_id: Schema.String.pipe(T.PathParam()),
@@ -13,10 +18,35 @@ export const VolumesExtendInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "PUT",
     path: "/apps/{app_name}/volumes/{volume_id}/extend",
   }),
-);
-export type VolumesExtendInput = typeof VolumesExtendInput.Type;
+) as unknown as Schema.Codec<VolumesExtendInput>;
 
 // Output Schema
+export interface VolumesExtendOutput {
+  needs_restart?: boolean;
+  volume?: {
+    attached_alloc_id?: string;
+    attached_machine_id?: string;
+    auto_backup_enabled?: boolean;
+    block_size?: number;
+    blocks?: number;
+    blocks_avail?: number;
+    blocks_free?: number;
+    bytes_total?: number;
+    bytes_used?: number;
+    created_at?: string;
+    encrypted?: boolean;
+    fstype?: string;
+    host_status?: "ok" | "unknown" | "unreachable";
+    id?: string;
+    name?: string;
+    region?: string;
+    size_gb?: number;
+    snapshot_retention?: number;
+    state?: string;
+    type?: "local" | "cache";
+    zone?: string;
+  };
+}
 export const VolumesExtendOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   needs_restart: Schema.optional(Schema.Boolean),
   volume: Schema.optional(
@@ -46,8 +76,7 @@ export const VolumesExtendOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       zone: Schema.optional(Schema.String),
     }),
   ),
-});
-export type VolumesExtendOutput = typeof VolumesExtendOutput.Type;
+}) as unknown as Schema.Codec<VolumesExtendOutput>;
 
 // The operation
 /**

package/src/operations/VolumesGetById.ts

@@ -4,15 +4,41 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface VolumesGetByIdInput {
+  app_name: string;
+  volume_id: string;
+}
 export const VolumesGetByIdInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   volume_id: Schema.String.pipe(T.PathParam()),
 }).pipe(
   T.Http({ method: "GET", path: "/apps/{app_name}/volumes/{volume_id}" }),
-);
-export type VolumesGetByIdInput = typeof VolumesGetByIdInput.Type;
+) as unknown as Schema.Codec<VolumesGetByIdInput>;
 
 // Output Schema
+export interface VolumesGetByIdOutput {
+  attached_alloc_id?: string;
+  attached_machine_id?: string;
+  auto_backup_enabled?: boolean;
+  block_size?: number;
+  blocks?: number;
+  blocks_avail?: number;
+  blocks_free?: number;
+  bytes_total?: number;
+  bytes_used?: number;
+  created_at?: string;
+  encrypted?: boolean;
+  fstype?: string;
+  host_status?: "ok" | "unknown" | "unreachable";
+  id?: string;
+  name?: string;
+  region?: string;
+  size_gb?: number;
+  snapshot_retention?: number;
+  state?: string;
+  type?: "local" | "cache";
+  zone?: string;
+}
 export const VolumesGetByIdOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   attached_alloc_id: Schema.optional(Schema.String),
   attached_machine_id: Schema.optional(Schema.String),
@@ -37,8 +63,7 @@ export const VolumesGetByIdOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   state: Schema.optional(Schema.String),
   type: Schema.optional(Schema.Literals(["local", "cache"])),
   zone: Schema.optional(Schema.String),
-});
-export type VolumesGetByIdOutput = typeof VolumesGetByIdOutput.Type;
+}) as unknown as Schema.Codec<VolumesGetByIdOutput>;
 
 // The operation
 /**

package/src/operations/VolumesList.ts

@@ -4,13 +4,41 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface VolumesListInput {
+  app_name: string;
+  summary?: boolean;
+}
 export const VolumesListInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   summary: Schema.optional(Schema.Boolean),
-}).pipe(T.Http({ method: "GET", path: "/apps/{app_name}/volumes" }));
-export type VolumesListInput = typeof VolumesListInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/apps/{app_name}/volumes" }),
+) as unknown as Schema.Codec<VolumesListInput>;
 
 // Output Schema
+export type VolumesListOutput = {
+  attached_alloc_id?: string;
+  attached_machine_id?: string;
+  auto_backup_enabled?: boolean;
+  block_size?: number;
+  blocks?: number;
+  blocks_avail?: number;
+  blocks_free?: number;
+  bytes_total?: number;
+  bytes_used?: number;
+  created_at?: string;
+  encrypted?: boolean;
+  fstype?: string;
+  host_status?: "ok" | "unknown" | "unreachable";
+  id?: string;
+  name?: string;
+  region?: string;
+  size_gb?: number;
+  snapshot_retention?: number;
+  state?: string;
+  type?: "local" | "cache";
+  zone?: string;
+}[];
 export const VolumesListOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
   Schema.Struct({
     attached_alloc_id: Schema.optional(Schema.String),
@@ -37,8 +65,7 @@ export const VolumesListOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     type: Schema.optional(Schema.Literals(["local", "cache"])),
     zone: Schema.optional(Schema.String),
   }),
-);
-export type VolumesListOutput = typeof VolumesListOutput.Type;
+) as unknown as Schema.Codec<VolumesListOutput>;
 
 // The operation
 /**

package/src/operations/VolumesListSnapshots.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface VolumesListSnapshotsInput {
+  app_name: string;
+  volume_id: string;
+}
 export const VolumesListSnapshotsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -13,10 +17,18 @@ export const VolumesListSnapshotsInput =
       method: "GET",
       path: "/apps/{app_name}/volumes/{volume_id}/snapshots",
     }),
-  );
-export type VolumesListSnapshotsInput = typeof VolumesListSnapshotsInput.Type;
+  ) as unknown as Schema.Codec<VolumesListSnapshotsInput>;
 
 // Output Schema
+export type VolumesListSnapshotsOutput = {
+  created_at?: string;
+  digest?: string;
+  id?: string;
+  retention_days?: number;
+  size?: number;
+  status?: string;
+  volume_size?: number;
+}[];
 export const VolumesListSnapshotsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -28,8 +40,7 @@ export const VolumesListSnapshotsOutput =
       status: Schema.optional(Schema.String),
       volume_size: Schema.optional(Schema.Number),
     }),
-  );
-export type VolumesListSnapshotsOutput = typeof VolumesListSnapshotsOutput.Type;
+  ) as unknown as Schema.Codec<VolumesListSnapshotsOutput>;
 
 // The operation
 /**