@distilled.cloud/fly-io 0.27.0 → 0.28.0

package/src/operations/AppCertificatesAcmeCreate.ts

@@ -9,17 +9,58 @@ import {
 } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesAcmeCreateInput {
+  app_name: string;
+  hostname?: string;
+}
 export const AppCertificatesAcmeCreateInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
     hostname: Schema.optional(Schema.String),
   }).pipe(
     T.Http({ method: "POST", path: "/apps/{app_name}/certificates/acme" }),
-  );
-export type AppCertificatesAcmeCreateInput =
-  typeof AppCertificatesAcmeCreateInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesAcmeCreateInput>;
 
 // Output Schema
+export interface AppCertificatesAcmeCreateOutput {
+  acme_requested?: boolean;
+  certificates?: {
+    created_at?: string;
+    expires_at?: string;
+    issued?: {
+      certificate_authority?: string;
+      expires_at?: string;
+      type?: "rsa" | "ecdsa";
+    }[];
+    issuer?: string;
+    source?: "custom" | "fly";
+    status?: "active" | "pending_ownership" | "pending_validation";
+  }[];
+  configured?: boolean;
+  dns_provider?: string;
+  dns_requirements?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge?: { name?: string; target?: string };
+    cname?: string;
+    ownership?: { app_value?: string; name?: string; org_value?: string };
+  };
+  hostname?: string;
+  rate_limited_until?: string;
+  status?: string;
+  validation?: {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+  };
+  validation_errors?: {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+  }[];
+}
 export const AppCertificatesAcmeCreateOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     acme_requested: Schema.optional(Schema.Boolean),
@@ -92,9 +133,7 @@ export const AppCertificatesAcmeCreateOutput =
         }),
       ),
     ),
-  });
-export type AppCertificatesAcmeCreateOutput =
-  typeof AppCertificatesAcmeCreateOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesAcmeCreateOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesAcmeDelete.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesAcmeDeleteInput {
+  app_name: string;
+  hostname: string;
+}
 export const AppCertificatesAcmeDeleteInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -13,11 +17,48 @@ export const AppCertificatesAcmeDeleteInput =
       method: "DELETE",
       path: "/apps/{app_name}/certificates/{hostname}/acme",
     }),
-  );
-export type AppCertificatesAcmeDeleteInput =
-  typeof AppCertificatesAcmeDeleteInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesAcmeDeleteInput>;
 
 // Output Schema
+export interface AppCertificatesAcmeDeleteOutput {
+  acme_requested?: boolean;
+  certificates?: {
+    created_at?: string;
+    expires_at?: string;
+    issued?: {
+      certificate_authority?: string;
+      expires_at?: string;
+      type?: "rsa" | "ecdsa";
+    }[];
+    issuer?: string;
+    source?: "custom" | "fly";
+    status?: "active" | "pending_ownership" | "pending_validation";
+  }[];
+  configured?: boolean;
+  dns_provider?: string;
+  dns_requirements?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge?: { name?: string; target?: string };
+    cname?: string;
+    ownership?: { app_value?: string; name?: string; org_value?: string };
+  };
+  hostname?: string;
+  rate_limited_until?: string;
+  status?: string;
+  validation?: {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+  };
+  validation_errors?: {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+  }[];
+}
 export const AppCertificatesAcmeDeleteOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     acme_requested: Schema.optional(Schema.Boolean),
@@ -90,9 +131,7 @@ export const AppCertificatesAcmeDeleteOutput =
         }),
       ),
     ),
-  });
-export type AppCertificatesAcmeDeleteOutput =
-  typeof AppCertificatesAcmeDeleteOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesAcmeDeleteOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesCheck.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesCheckInput {
+  app_name: string;
+  hostname: string;
+}
 export const AppCertificatesCheckInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -13,10 +17,57 @@ export const AppCertificatesCheckInput =
       method: "POST",
       path: "/apps/{app_name}/certificates/{hostname}/check",
     }),
-  );
-export type AppCertificatesCheckInput = typeof AppCertificatesCheckInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesCheckInput>;
 
 // Output Schema
+export interface AppCertificatesCheckOutput {
+  acme_requested?: boolean;
+  certificates?: {
+    created_at?: string;
+    expires_at?: string;
+    issued?: {
+      certificate_authority?: string;
+      expires_at?: string;
+      type?: "rsa" | "ecdsa";
+    }[];
+    issuer?: string;
+    source?: "custom" | "fly";
+    status?: "active" | "pending_ownership" | "pending_validation";
+  }[];
+  configured?: boolean;
+  dns_provider?: string;
+  dns_records?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge_cname?: string;
+    cname?: string[];
+    ownership_txt?: string;
+    resolved_addresses?: string[];
+    soa?: string;
+  };
+  dns_requirements?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge?: { name?: string; target?: string };
+    cname?: string;
+    ownership?: { app_value?: string; name?: string; org_value?: string };
+  };
+  hostname?: string;
+  rate_limited_until?: string;
+  status?: string;
+  validation?: {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+  };
+  validation_errors?: {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+  }[];
+}
 export const AppCertificatesCheckOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     acme_requested: Schema.optional(Schema.Boolean),
@@ -100,8 +151,7 @@ export const AppCertificatesCheckOutput =
         }),
       ),
     ),
-  });
-export type AppCertificatesCheckOutput = typeof AppCertificatesCheckOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesCheckOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesCustomCreate.ts

@@ -8,8 +8,15 @@ import {
   UnprocessableEntity,
 } from "../errors.ts";
 import { SensitiveString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface AppCertificatesCustomCreateInput {
+  app_name: string;
+  fullchain?: string;
+  hostname?: string;
+  private_key?: string | Redacted.Redacted<string>;
+}
 export const AppCertificatesCustomCreateInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -18,11 +25,48 @@ export const AppCertificatesCustomCreateInput =
     private_key: Schema.optional(SensitiveString),
   }).pipe(
     T.Http({ method: "POST", path: "/apps/{app_name}/certificates/custom" }),
-  );
-export type AppCertificatesCustomCreateInput =
-  typeof AppCertificatesCustomCreateInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesCustomCreateInput>;
 
 // Output Schema
+export interface AppCertificatesCustomCreateOutput {
+  acme_requested?: boolean;
+  certificates?: {
+    created_at?: string;
+    expires_at?: string;
+    issued?: {
+      certificate_authority?: string;
+      expires_at?: string;
+      type?: "rsa" | "ecdsa";
+    }[];
+    issuer?: string;
+    source?: "custom" | "fly";
+    status?: "active" | "pending_ownership" | "pending_validation";
+  }[];
+  configured?: boolean;
+  dns_provider?: string;
+  dns_requirements?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge?: { name?: string; target?: string };
+    cname?: string;
+    ownership?: { app_value?: string; name?: string; org_value?: string };
+  };
+  hostname?: string;
+  rate_limited_until?: string;
+  status?: string;
+  validation?: {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+  };
+  validation_errors?: {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+  }[];
+}
 export const AppCertificatesCustomCreateOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     acme_requested: Schema.optional(Schema.Boolean),
@@ -95,9 +139,7 @@ export const AppCertificatesCustomCreateOutput =
         }),
       ),
     ),
-  });
-export type AppCertificatesCustomCreateOutput =
-  typeof AppCertificatesCustomCreateOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesCustomCreateOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesCustomDelete.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesCustomDeleteInput {
+  app_name: string;
+  hostname: string;
+}
 export const AppCertificatesCustomDeleteInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -13,11 +17,49 @@ export const AppCertificatesCustomDeleteInput =
       method: "DELETE",
       path: "/apps/{app_name}/certificates/{hostname}/custom",
     }),
-  );
-export type AppCertificatesCustomDeleteInput =
-  typeof AppCertificatesCustomDeleteInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesCustomDeleteInput>;
 
 // Output Schema
+export interface AppCertificatesCustomDeleteOutput {
+  acme_requested?: boolean;
+  certificates?: {
+    created_at?: string;
+    expires_at?: string;
+    issued?: {
+      certificate_authority?: string;
+      expires_at?: string;
+      type?: "rsa" | "ecdsa";
+    }[];
+    issuer?: string;
+    source?: "custom" | "fly";
+    status?: "active" | "pending_ownership" | "pending_validation";
+  }[];
+  configured?: boolean;
+  dns_provider?: string;
+  dns_requirements?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge?: { name?: string; target?: string };
+    cname?: string;
+    ownership?: { app_value?: string; name?: string; org_value?: string };
+  };
+  hostname?: string;
+  rate_limited_until?: string;
+  status?: string;
+  validation?: {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+  };
+  validation_errors?: {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+  }[];
+  warning?: string;
+}
 export const AppCertificatesCustomDeleteOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     acme_requested: Schema.optional(Schema.Boolean),
@@ -91,9 +133,7 @@ export const AppCertificatesCustomDeleteOutput =
       ),
     ),
     warning: Schema.optional(Schema.String),
-  });
-export type AppCertificatesCustomDeleteOutput =
-  typeof AppCertificatesCustomDeleteOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesCustomDeleteOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesDelete.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesDeleteInput {
+  app_name: string;
+  hostname: string;
+}
 export const AppCertificatesDeleteInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -13,14 +17,12 @@ export const AppCertificatesDeleteInput =
       method: "DELETE",
       path: "/apps/{app_name}/certificates/{hostname}",
     }),
-  );
-export type AppCertificatesDeleteInput = typeof AppCertificatesDeleteInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesDeleteInput>;
 
 // Output Schema
+export type AppCertificatesDeleteOutput = void;
 export const AppCertificatesDeleteOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type AppCertificatesDeleteOutput =
-  typeof AppCertificatesDeleteOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<AppCertificatesDeleteOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesList.ts

@@ -4,16 +4,42 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesListInput {
+  app_name: string;
+  filter?: string;
+  cursor?: string;
+  limit?: number;
+}
 export const AppCertificatesListInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
     filter: Schema.optional(Schema.String),
     cursor: Schema.optional(Schema.String),
     limit: Schema.optional(Schema.Number),
-  }).pipe(T.Http({ method: "GET", path: "/apps/{app_name}/certificates" }));
-export type AppCertificatesListInput = typeof AppCertificatesListInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/apps/{app_name}/certificates" }),
+  ) as unknown as Schema.Codec<AppCertificatesListInput>;
 
 // Output Schema
+export interface AppCertificatesListOutput {
+  certificates?: {
+    acme_alpn_configured?: boolean;
+    acme_dns_configured?: boolean;
+    acme_http_configured?: boolean;
+    acme_requested?: boolean;
+    configured?: boolean;
+    created_at?: string;
+    dns_provider?: string;
+    has_custom_certificate?: boolean;
+    has_fly_certificate?: boolean;
+    hostname?: string;
+    ownership_txt_configured?: boolean;
+    status?: string;
+    updated_at?: string;
+  }[];
+  next_cursor?: string;
+  total_count?: number;
+}
 export const AppCertificatesListOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     certificates: Schema.optional(
@@ -37,8 +63,7 @@ export const AppCertificatesListOutput =
     ),
     next_cursor: Schema.optional(Schema.String),
     total_count: Schema.optional(Schema.Number),
-  });
-export type AppCertificatesListOutput = typeof AppCertificatesListOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesListOutput>;
 
 // The operation
 /**

package/src/operations/AppCertificatesShow.ts

@@ -4,16 +4,58 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCertificatesShowInput {
+  app_name: string;
+  hostname: string;
+}
 export const AppCertificatesShowInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
     hostname: Schema.String.pipe(T.PathParam()),
   }).pipe(
     T.Http({ method: "GET", path: "/apps/{app_name}/certificates/{hostname}" }),
-  );
-export type AppCertificatesShowInput = typeof AppCertificatesShowInput.Type;
+  ) as unknown as Schema.Codec<AppCertificatesShowInput>;
 
 // Output Schema
+export interface AppCertificatesShowOutput {
+  acme_requested?: boolean;
+  certificates?: {
+    created_at?: string;
+    expires_at?: string;
+    issued?: {
+      certificate_authority?: string;
+      expires_at?: string;
+      type?: "rsa" | "ecdsa";
+    }[];
+    issuer?: string;
+    source?: "custom" | "fly";
+    status?: "active" | "pending_ownership" | "pending_validation";
+  }[];
+  configured?: boolean;
+  dns_provider?: string;
+  dns_requirements?: {
+    a?: string[];
+    aaaa?: string[];
+    acme_challenge?: { name?: string; target?: string };
+    cname?: string;
+    ownership?: { app_value?: string; name?: string; org_value?: string };
+  };
+  hostname?: string;
+  rate_limited_until?: string;
+  status?: string;
+  validation?: {
+    alpn_configured?: boolean;
+    dns_configured?: boolean;
+    http_configured?: boolean;
+    ownership_txt_configured?: boolean;
+  };
+  validation_errors?: {
+    code?: string;
+    message?: string;
+    remediation?: string;
+    timestamp?: string;
+  }[];
+}
 export const AppCertificatesShowOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     acme_requested: Schema.optional(Schema.Boolean),
@@ -86,8 +128,7 @@ export const AppCertificatesShowOutput =
         }),
       ),
     ),
-  });
-export type AppCertificatesShowOutput = typeof AppCertificatesShowOutput.Type;
+  }) as unknown as Schema.Codec<AppCertificatesShowOutput>;
 
 // The operation
 /**

package/src/operations/AppCreateDeployToken.ts

@@ -4,19 +4,26 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppCreateDeployTokenInput {
+  app_name: string;
+  expiry?: string;
+}
 export const AppCreateDeployTokenInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
     expiry: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "POST", path: "/apps/{app_name}/deploy_token" }));
-export type AppCreateDeployTokenInput = typeof AppCreateDeployTokenInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/apps/{app_name}/deploy_token" }),
+  ) as unknown as Schema.Codec<AppCreateDeployTokenInput>;
 
 // Output Schema
+export interface AppCreateDeployTokenOutput {
+  token?: string;
+}
 export const AppCreateDeployTokenOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     token: Schema.optional(Schema.String),
-  });
-export type AppCreateDeployTokenOutput = typeof AppCreateDeployTokenOutput.Type;
+  }) as unknown as Schema.Codec<AppCreateDeployTokenOutput>;
 
 // The operation
 /**

package/src/operations/AppIPAssignmentsCreate.ts

@@ -4,6 +4,14 @@ import * as T from "../traits.ts";
 import { BadRequest, Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppIPAssignmentsCreateInput {
+  app_name: string;
+  network?: string;
+  org_slug?: string;
+  region?: string;
+  service_name?: string;
+  type?: string;
+}
 export const AppIPAssignmentsCreateInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
@@ -12,11 +20,18 @@ export const AppIPAssignmentsCreateInput =
     region: Schema.optional(Schema.String),
     service_name: Schema.optional(Schema.String),
     type: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "POST", path: "/apps/{app_name}/ip_assignments" }));
-export type AppIPAssignmentsCreateInput =
-  typeof AppIPAssignmentsCreateInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/apps/{app_name}/ip_assignments" }),
+  ) as unknown as Schema.Codec<AppIPAssignmentsCreateInput>;
 
 // Output Schema
+export interface AppIPAssignmentsCreateOutput {
+  created_at?: string;
+  ip?: string;
+  region?: string;
+  service_name?: string;
+  shared?: boolean;
+}
 export const AppIPAssignmentsCreateOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     created_at: Schema.optional(Schema.String),
@@ -24,9 +39,7 @@ export const AppIPAssignmentsCreateOutput =
     region: Schema.optional(Schema.String),
     service_name: Schema.optional(Schema.String),
     shared: Schema.optional(Schema.Boolean),
-  });
-export type AppIPAssignmentsCreateOutput =
-  typeof AppIPAssignmentsCreateOutput.Type;
+  }) as unknown as Schema.Codec<AppIPAssignmentsCreateOutput>;
 
 // The operation
 /**

package/src/operations/AppIPAssignmentsDelete.ts

@@ -4,21 +4,22 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppIPAssignmentsDeleteInput {
+  app_name: string;
+  ip: string;
+}
 export const AppIPAssignmentsDeleteInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
     ip: Schema.String.pipe(T.PathParam()),
   }).pipe(
     T.Http({ method: "DELETE", path: "/apps/{app_name}/ip_assignments/{ip}" }),
-  );
-export type AppIPAssignmentsDeleteInput =
-  typeof AppIPAssignmentsDeleteInput.Type;
+  ) as unknown as Schema.Codec<AppIPAssignmentsDeleteInput>;
 
 // Output Schema
+export type AppIPAssignmentsDeleteOutput = void;
 export const AppIPAssignmentsDeleteOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type AppIPAssignmentsDeleteOutput =
-  typeof AppIPAssignmentsDeleteOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<AppIPAssignmentsDeleteOutput>;
 
 // The operation
 /**

package/src/operations/AppIPAssignmentsList.ts

@@ -4,13 +4,26 @@ import * as T from "../traits.ts";
 import { Forbidden, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface AppIPAssignmentsListInput {
+  app_name: string;
+}
 export const AppIPAssignmentsListInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     app_name: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/apps/{app_name}/ip_assignments" }));
-export type AppIPAssignmentsListInput = typeof AppIPAssignmentsListInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/apps/{app_name}/ip_assignments" }),
+  ) as unknown as Schema.Codec<AppIPAssignmentsListInput>;
 
 // Output Schema
+export interface AppIPAssignmentsListOutput {
+  ips?: {
+    created_at?: string;
+    ip?: string;
+    region?: string;
+    service_name?: string;
+    shared?: boolean;
+  }[];
+}
 export const AppIPAssignmentsListOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     ips: Schema.optional(
@@ -24,8 +37,7 @@ export const AppIPAssignmentsListOutput =
         }),
       ),
     ),
-  });
-export type AppIPAssignmentsListOutput = typeof AppIPAssignmentsListOutput.Type;
+  }) as unknown as Schema.Codec<AppIPAssignmentsListOutput>;
 
 // The operation
 /**