@distilled.cloud/fly-io 0.26.1 → 0.28.0

package/src/operations/MachinesUpdateMetadata.ts

@@ -1,9 +1,16 @@
 import * as Schema from "effect/Schema";
 import { API } from "../client.ts";
 import * as T from "../traits.ts";
-import { BadRequest, Forbidden, NotFound } from "../errors.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__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -13,18 +20,15 @@ export const MachinesUpdateMetadataInput =
     updated_at: Schema.optional(Schema.String),
   }).pipe(
     T.Http({
-      method: "PUT",
+      method: "PATCH",
       path: "/apps/{app_name}/machines/{machine_id}/metadata",
     }),
-  );
-export type MachinesUpdateMetadataInput =
-  typeof MachinesUpdateMetadataInput.Type;
+  ) as unknown as Schema.Codec<MachinesUpdateMetadataInput>;
 
 // Output Schema
+export type MachinesUpdateMetadataOutput = void;
 export const MachinesUpdateMetadataOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type MachinesUpdateMetadataOutput =
-  typeof MachinesUpdateMetadataOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<MachinesUpdateMetadataOutput>;
 
 // The operation
 /**
@@ -40,6 +44,6 @@ export const MachinesUpdateMetadata = /*@__PURE__*/ /*#__PURE__*/ API.make(
   () => ({
     inputSchema: MachinesUpdateMetadataInput,
     outputSchema: MachinesUpdateMetadataOutput,
-    errors: [BadRequest, Forbidden, NotFound] as const,
+    errors: [BadRequest] as const,
   }),
 );

package/src/operations/MachinesUpsertMetadata.ts

@@ -4,6 +4,13 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -16,15 +23,12 @@ export const MachinesUpsertMetadataInput =
       method: "POST",
       path: "/apps/{app_name}/machines/{machine_id}/metadata/{key}",
     }),
-  );
-export type MachinesUpsertMetadataInput =
-  typeof MachinesUpsertMetadataInput.Type;
+  ) as unknown as Schema.Codec<MachinesUpsertMetadataInput>;
 
 // Output Schema
+export type MachinesUpsertMetadataOutput = void;
 export const MachinesUpsertMetadataOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type MachinesUpsertMetadataOutput =
-  typeof MachinesUpsertMetadataOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<MachinesUpsertMetadataOutput>;
 
 // The operation
 /**

package/src/operations/MachinesWait.ts

@@ -4,6 +4,21 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   machine_id: Schema.String.pipe(T.PathParam()),
@@ -26,17 +41,21 @@ export const MachinesWaitInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "GET",
     path: "/apps/{app_name}/machines/{machine_id}/wait",
   }),
-);
-export type MachinesWaitInput = typeof MachinesWaitInput.Type;
+) as unknown as Schema.Codec<MachinesWaitInput>;
 
 // Output Schema
+export interface MachinesWaitOutput {
+  event_id?: string;
+  ok?: boolean;
+  state?: string;
+  version?: string;
+}
 export const MachinesWaitOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   event_id: Schema.optional(Schema.String),
   ok: Schema.optional(Schema.Boolean),
   state: Schema.optional(Schema.String),
   version: Schema.optional(Schema.String),
-});
-export type MachinesWaitOutput = typeof MachinesWaitOutput.Type;
+}) as unknown as Schema.Codec<MachinesWaitOutput>;
 
 // The operation
 /**

package/src/operations/PlatformPlacementsPost.ts

@@ -4,6 +4,25 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
     compute: Schema.optional(
@@ -27,11 +46,14 @@ export const PlatformPlacementsPostInput =
     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" }));
-export type PlatformPlacementsPostInput =
-  typeof PlatformPlacementsPostInput.Type;
+  }).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__*/ /*#__PURE__*/ Schema.Struct({
     regions: Schema.optional(
@@ -43,9 +65,7 @@ export const PlatformPlacementsPostOutput =
         }),
       ),
     ),
-  });
-export type PlatformPlacementsPostOutput =
-  typeof PlatformPlacementsPostOutput.Type;
+  }) as unknown as Schema.Codec<PlatformPlacementsPostOutput>;
 
 // The operation
 /**

package/src/operations/PlatformRegionsGet.ts

@@ -4,13 +4,26 @@ import * as T from "../traits.ts";
 import { Forbidden } from "../errors.ts";
 
 // Input Schema
+export interface PlatformRegionsGetInput {}
 export const PlatformRegionsGetInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/platform/regions" }),
-  );
-export type PlatformRegionsGetInput = typeof PlatformRegionsGetInput.Type;
+  ) 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__*/ /*#__PURE__*/ Schema.Struct({
     nearest: Schema.optional(Schema.String),
@@ -28,8 +41,7 @@ export const PlatformRegionsGetOutput =
         }),
       ),
     ),
-  });
-export type PlatformRegionsGetOutput = typeof PlatformRegionsGetOutput.Type;
+  }) as unknown as Schema.Codec<PlatformRegionsGetOutput>;
 
 // The operation
 /**

package/src/operations/SecretCreate.ts

@@ -4,16 +4,29 @@ 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__*/ /*#__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}" }),
-);
-export type SecretCreateInput = typeof SecretCreateInput.Type;
+) 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__*/ /*#__PURE__*/ Schema.Struct({
   Version: Schema.optional(Schema.Number),
   created_at: Schema.optional(Schema.String),
@@ -22,8 +35,7 @@ export const SecretCreateOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   updated_at: Schema.optional(Schema.String),
   value: Schema.optional(Schema.String),
   version: Schema.optional(Schema.Number),
-});
-export type SecretCreateOutput = typeof SecretCreateOutput.Type;
+}) as unknown as Schema.Codec<SecretCreateOutput>;
 
 // The operation
 /**

package/src/operations/SecretDelete.ts

@@ -4,20 +4,26 @@ 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__*/ /*#__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}" }),
-);
-export type SecretDeleteInput = typeof SecretDeleteInput.Type;
+) as unknown as Schema.Codec<SecretDeleteInput>;
 
 // Output Schema
+export interface SecretDeleteOutput {
+  Version?: number;
+  version?: number;
+}
 export const SecretDeleteOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   Version: Schema.optional(Schema.Number),
   version: Schema.optional(Schema.Number),
-});
-export type SecretDeleteOutput = typeof SecretDeleteOutput.Type;
+}) as unknown as Schema.Codec<SecretDeleteOutput>;
 
 // The operation
 /**

package/src/operations/SecretGet.ts

@@ -4,6 +4,12 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -11,18 +17,23 @@ export const SecretGetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   show_secrets: Schema.optional(Schema.Boolean),
 }).pipe(
   T.Http({ method: "GET", path: "/apps/{app_name}/secrets/{secret_name}" }),
-);
-export type SecretGetInput = typeof SecretGetInput.Type;
+) 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__*/ /*#__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),
-});
-export type SecretGetOutput = typeof SecretGetOutput.Type;
+}) as unknown as Schema.Codec<SecretGetOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeyDecrypt.ts

@@ -4,6 +4,13 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -15,16 +22,17 @@ export const SecretkeyDecryptInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "POST",
     path: "/apps/{app_name}/secretkeys/{secret_name}/decrypt",
   }),
-);
-export type SecretkeyDecryptInput = typeof SecretkeyDecryptInput.Type;
+) as unknown as Schema.Codec<SecretkeyDecryptInput>;
 
 // Output Schema
+export interface SecretkeyDecryptOutput {
+  plaintext?: number[];
+}
 export const SecretkeyDecryptOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     plaintext: Schema.optional(Schema.Array(Schema.Number)),
   },
-);
-export type SecretkeyDecryptOutput = typeof SecretkeyDecryptOutput.Type;
+) as unknown as Schema.Codec<SecretkeyDecryptOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeyDelete.ts

@@ -4,6 +4,10 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -12,15 +16,17 @@ export const SecretkeyDeleteInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "DELETE",
     path: "/apps/{app_name}/secretkeys/{secret_name}",
   }),
-);
-export type SecretkeyDeleteInput = typeof SecretkeyDeleteInput.Type;
+) as unknown as Schema.Codec<SecretkeyDeleteInput>;
 
 // Output Schema
+export interface SecretkeyDeleteOutput {
+  Version?: number;
+  version?: number;
+}
 export const SecretkeyDeleteOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   Version: Schema.optional(Schema.Number),
   version: Schema.optional(Schema.Number),
-});
-export type SecretkeyDeleteOutput = typeof SecretkeyDeleteOutput.Type;
+}) as unknown as Schema.Codec<SecretkeyDeleteOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeyEncrypt.ts

@@ -4,6 +4,13 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -15,16 +22,17 @@ export const SecretkeyEncryptInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "POST",
     path: "/apps/{app_name}/secretkeys/{secret_name}/encrypt",
   }),
-);
-export type SecretkeyEncryptInput = typeof SecretkeyEncryptInput.Type;
+) as unknown as Schema.Codec<SecretkeyEncryptInput>;
 
 // Output Schema
+export interface SecretkeyEncryptOutput {
+  ciphertext?: number[];
+}
 export const SecretkeyEncryptOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     ciphertext: Schema.optional(Schema.Array(Schema.Number)),
   },
-);
-export type SecretkeyEncryptOutput = typeof SecretkeyEncryptOutput.Type;
+) as unknown as Schema.Codec<SecretkeyEncryptOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeyGenerate.ts

@@ -4,6 +4,12 @@ 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__*/ /*#__PURE__*/ Schema.Struct(
   {
     app_name: Schema.String.pipe(T.PathParam()),
@@ -16,10 +22,18 @@ export const SecretkeyGenerateInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     method: "POST",
     path: "/apps/{app_name}/secretkeys/{secret_name}/generate",
   }),
-);
-export type SecretkeyGenerateInput = typeof SecretkeyGenerateInput.Type;
+) 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__*/ /*#__PURE__*/ Schema.Struct({
     Version: Schema.optional(Schema.Number),
@@ -29,8 +43,7 @@ export const SecretkeyGenerateOutput =
     type: Schema.optional(Schema.String),
     updated_at: Schema.optional(Schema.String),
     version: Schema.optional(Schema.Number),
-  });
-export type SecretkeyGenerateOutput = typeof SecretkeyGenerateOutput.Type;
+  }) as unknown as Schema.Codec<SecretkeyGenerateOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeyGet.ts

@@ -4,24 +4,34 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretkeyGetInput {
+  app_name: string;
+  secret_name: string;
+  min_version?: string;
+}
 export const SecretkeyGetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
   min_version: Schema.optional(Schema.String),
 }).pipe(
   T.Http({ method: "GET", path: "/apps/{app_name}/secretkeys/{secret_name}" }),
-);
-export type SecretkeyGetInput = typeof SecretkeyGetInput.Type;
+) as unknown as Schema.Codec<SecretkeyGetInput>;
 
 // Output Schema
+export interface SecretkeyGetOutput {
+  created_at?: string;
+  name?: string;
+  public_key?: number[];
+  type?: string;
+  updated_at?: string;
+}
 export const SecretkeyGetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   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),
-});
-export type SecretkeyGetOutput = typeof SecretkeyGetOutput.Type;
+}) as unknown as Schema.Codec<SecretkeyGetOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeySet.ts

@@ -4,6 +4,12 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretkeySetInput {
+  app_name: string;
+  secret_name: string;
+  type?: string;
+  value?: number[];
+}
 export const SecretkeySetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -11,10 +17,18 @@ export const SecretkeySetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   value: Schema.optional(Schema.Array(Schema.Number)),
 }).pipe(
   T.Http({ method: "POST", path: "/apps/{app_name}/secretkeys/{secret_name}" }),
-);
-export type SecretkeySetInput = typeof SecretkeySetInput.Type;
+) as unknown as Schema.Codec<SecretkeySetInput>;
 
 // Output Schema
+export interface SecretkeySetOutput {
+  Version?: number;
+  created_at?: string;
+  name?: string;
+  public_key?: number[];
+  type?: string;
+  updated_at?: string;
+  version?: number;
+}
 export const SecretkeySetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   Version: Schema.optional(Schema.Number),
   created_at: Schema.optional(Schema.String),
@@ -23,8 +37,7 @@ export const SecretkeySetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   type: Schema.optional(Schema.String),
   updated_at: Schema.optional(Schema.String),
   version: Schema.optional(Schema.Number),
-});
-export type SecretkeySetOutput = typeof SecretkeySetOutput.Type;
+}) as unknown as Schema.Codec<SecretkeySetOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeySign.ts

@@ -4,6 +4,12 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretkeySignInput {
+  app_name: string;
+  secret_name: string;
+  min_version?: string;
+  plaintext?: number[];
+}
 export const SecretkeySignInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -14,14 +20,15 @@ export const SecretkeySignInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "POST",
     path: "/apps/{app_name}/secretkeys/{secret_name}/sign",
   }),
-);
-export type SecretkeySignInput = typeof SecretkeySignInput.Type;
+) as unknown as Schema.Codec<SecretkeySignInput>;
 
 // Output Schema
+export interface SecretkeySignOutput {
+  signature?: number[];
+}
 export const SecretkeySignOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   signature: Schema.optional(Schema.Array(Schema.Number)),
-});
-export type SecretkeySignOutput = typeof SecretkeySignOutput.Type;
+}) as unknown as Schema.Codec<SecretkeySignOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeyVerify.ts

@@ -4,6 +4,13 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretkeyVerifyInput {
+  app_name: string;
+  secret_name: string;
+  min_version?: string;
+  plaintext?: number[];
+  signature?: number[];
+}
 export const SecretkeyVerifyInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   secret_name: Schema.String.pipe(T.PathParam()),
@@ -15,12 +22,12 @@ export const SecretkeyVerifyInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "POST",
     path: "/apps/{app_name}/secretkeys/{secret_name}/verify",
   }),
-);
-export type SecretkeyVerifyInput = typeof SecretkeyVerifyInput.Type;
+) as unknown as Schema.Codec<SecretkeyVerifyInput>;
 
 // Output Schema
-export const SecretkeyVerifyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type SecretkeyVerifyOutput = typeof SecretkeyVerifyOutput.Type;
+export type SecretkeyVerifyOutput = void;
+export const SecretkeyVerifyOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<SecretkeyVerifyOutput>;
 
 // The operation
 /**

package/src/operations/SecretkeysList.ts

@@ -4,14 +4,29 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SecretkeysListInput {
+  app_name: string;
+  min_version?: string;
+  types?: string;
+}
 export const SecretkeysListInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   app_name: Schema.String.pipe(T.PathParam()),
   min_version: Schema.optional(Schema.String),
   types: Schema.optional(Schema.String),
-}).pipe(T.Http({ method: "GET", path: "/apps/{app_name}/secretkeys" }));
-export type SecretkeysListInput = typeof SecretkeysListInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/apps/{app_name}/secretkeys" }),
+) as unknown as Schema.Codec<SecretkeysListInput>;
 
 // Output Schema
+export interface SecretkeysListOutput {
+  secret_keys?: {
+    created_at?: string;
+    name?: string;
+    public_key?: number[];
+    type?: string;
+    updated_at?: string;
+  }[];
+}
 export const SecretkeysListOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   secret_keys: Schema.optional(
     Schema.Array(
@@ -24,8 +39,7 @@ export const SecretkeysListOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       }),
     ),
   ),
-});
-export type SecretkeysListOutput = typeof SecretkeysListOutput.Type;
+}) as unknown as Schema.Codec<SecretkeysListOutput>;
 
 // The operation
 /**