@interfere/sdk 0.0.1-alpha.23 → 0.0.1-alpha.31

package/src/lib/env.ts

@@ -7,14 +7,10 @@ import * as z from "zod/v4-mini";
 import { dlv } from "./dlv.js";
 
 export interface Env {
-  INTERFERE_API_KEY?: string | undefined;
-
   INTERFERE_DEBUG?: boolean | undefined;
 }
 
 export const envSchema: z.ZodMiniType<Env, unknown> = z.object({
-  INTERFERE_API_KEY: z.optional(z.string()),
-
   INTERFERE_DEBUG: z.optional(z.coerce.boolean()),
 });
 
@@ -30,7 +26,7 @@ function isDeno() {
   return false;
 }
 
-let envMemo: Env | undefined = undefined;
+let envMemo: Env | undefined ;
 /**
  * Reads and validates environment variables.
  */

package/src/lib/http.ts

@@ -206,7 +206,7 @@ export function matchContentType(response: Response, pattern: string): boolean {
   return true;
 }
 
-const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+const codeRangeRE = /^[0-9]xx$/i;
 
 export function matchStatusCode(
   response: Response,

package/src/lib/matchers.ts

@@ -5,8 +5,8 @@
 
 import { InterfereError } from "../models/errors/interfere-error.js";
 import { ResponseValidationError } from "../models/errors/response-validation-error.js";
-import { ERR, OK, Result } from "../types/fp.js";
-import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
+import { ERR, OK, type Result } from "../types/fp.js";
+import { matchResponse, matchStatusCode, type StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
 
 export type Encoding =
@@ -252,8 +252,9 @@ export function match<T, E>(
         raw = body;
         break;
       default:
-        encoding satisfies never;
-        throw new Error(`Unsupported response type: ${encoding}`);
+        throw new Error(
+          `Unsupported response type: ${encoding satisfies never}`,
+        );
     }
 
     if (matcher.enc === "fail") {

package/src/lib/retries.ts

@@ -126,7 +126,7 @@ function wrapFetcher(
   };
 }
 
-const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+const codeRangeRE = /^[0-9]xx$/i;
 
 function isRetryableResponse(res: Response, statusCodes: string[]): boolean {
   const actual = `${res.status}`;
@@ -183,7 +183,7 @@ async function retryBackoff(
 
       if (retryInterval <= 0) {
         retryInterval =
-          initialInterval * Math.pow(x, exponent) + Math.random() * 1000;
+          initialInterval * x ** exponent + Math.random() * 1000;
       }
 
       const d = Math.min(retryInterval, maxInterval);

package/src/lib/schemas.ts

@@ -5,7 +5,7 @@
 
 import * as z from "zod/v4-mini";
 import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
-import { ERR, OK, Result } from "../types/fp.js";
+import { ERR, OK, type Result } from "../types/fp.js";
 
 /**
  * Utility function that executes some code which may throw a ZodError. It

package/src/lib/sdks.ts

@@ -4,7 +4,7 @@
  */
 
 import { SDKHooks } from "../hooks/hooks.js";
-import { HookContext } from "../hooks/types.js";
+import type { HookContext } from "../hooks/types.js";
 import {
   ConnectionError,
   InvalidRequestError,
@@ -12,9 +12,9 @@ import {
   RequestTimeoutError,
   UnexpectedClientError,
 } from "../models/errors/http-client-errors.js";
-import { ERR, OK, Result } from "../types/fp.js";
+import { ERR, OK, type Result } from "../types/fp.js";
 import { stringToBase64 } from "./base64.js";
-import { SDK_METADATA, SDKOptions, serverURLFromOptions } from "./config.js";
+import { SDK_METADATA, type SDKOptions, serverURLFromOptions } from "./config.js";
 import { encodeForm } from "./encodings.js";
 import { env } from "./env.js";
 import {
@@ -25,9 +25,9 @@ import {
   matchContentType,
   matchStatusCode,
 } from "./http.js";
-import { Logger } from "./logger.js";
-import { retry, RetryConfig } from "./retries.js";
-import { SecurityState } from "./security.js";
+import type { Logger } from "./logger.js";
+import { retry, type RetryConfig } from "./retries.js";
+import type { SecurityState } from "./security.js";
 
 export type RequestOptions = {
   /**

package/src/lib/security.ts

@@ -3,9 +3,6 @@
  * @generated-id: 560349437417
  */
 
-import { Security } from "../models/security.js";
-import { env } from "./env.js";
-
 type OAuth2PasswordFlow = {
   username: string;
   password: string;
@@ -199,8 +196,7 @@ export function resolveSecurity(
         applyBearer(state, spec);
         break;
       default:
-        spec satisfies never;
-        throw SecurityError.unrecognizedType(type);
+        throw SecurityError.unrecognizedType((spec satisfies never, type));
     }
   });
 
@@ -239,27 +235,3 @@ function applyBearer(
     state.headers[spec.fieldName] = value;
   }
 }
-
-export function resolveGlobalSecurity(
-  security: Partial<Security> | null | undefined,
-): SecurityState | null {
-  return resolveSecurity(
-    [
-      {
-        fieldName: "x-api-key",
-        type: "apiKey:header",
-        value: security?.apiKey ?? env().INTERFERE_API_KEY,
-      },
-    ],
-  );
-}
-
-export async function extractSecurity<
-  T extends string | Record<string, unknown>,
->(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined> {
-  if (sec == null) {
-    return;
-  }
-
-  return typeof sec === "function" ? sec() : sec;
-}

package/src/lib/url.ts

@@ -14,7 +14,7 @@ export function pathToFunc(
   const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
 
   return function buildURLPath(params: Record<string, unknown> = {}): string {
-    return pathPattern.replace(paramRE, function (_, placeholder) {
+    return pathPattern.replace(paramRE, (_, placeholder) => {
       if (!hasOwn.call(params, placeholder)) {
         throw new Error(`Parameter '${placeholder}' is required`);
       }

package/src/models/health-ok.ts

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0364eb8c38c7
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import type { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import type { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type HealthOk = {
+  status: "ok";
+};
+
+/** @internal */
+export const HealthOk$inboundSchema: z.ZodMiniType<HealthOk, unknown> = z
+  .object({
+    status: types.literal("ok"),
+  });
+
+export function healthOkFromJSON(
+  jsonString: string,
+): SafeParseResult<HealthOk, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HealthOk$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HealthOk' from JSON`,
+  );
+}

package/src/models/operations/upload-source-maps.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c6cb209307c3
+ */
+
+import * as z from "zod/v4-mini";
+import {
+  type ReleasesUploadSourceMapsRequest,
+  type ReleasesUploadSourceMapsRequest$Outbound,
+  ReleasesUploadSourceMapsRequest$outboundSchema,
+} from "../releases-upload-source-maps-request.js";
+
+export type UploadSourceMapsRequest = {
+  releaseSlug: string;
+  body: ReleasesUploadSourceMapsRequest;
+};
+
+/** @internal */
+export type UploadSourceMapsRequest$Outbound = {
+  releaseSlug: string;
+  body: ReleasesUploadSourceMapsRequest$Outbound;
+};
+
+/** @internal */
+export const UploadSourceMapsRequest$outboundSchema: z.ZodMiniType<
+  UploadSourceMapsRequest$Outbound,
+  UploadSourceMapsRequest
+> = z.object({
+  releaseSlug: z.string(),
+  body: ReleasesUploadSourceMapsRequest$outboundSchema,
+});
+
+export function uploadSourceMapsRequestToJSON(
+  uploadSourceMapsRequest: UploadSourceMapsRequest,
+): string {
+  return JSON.stringify(
+    UploadSourceMapsRequest$outboundSchema.parse(uploadSourceMapsRequest),
+  );
+}

package/src/models/releases-create-release-request.ts

@@ -0,0 +1,137 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e69aee75044c
+ */
+
+import * as z from "zod/v4-mini";
+
+export type SourceGithub = {
+  commitMessage: string;
+  branch: string;
+  commitSha: string | null;
+  provider: "github";
+};
+
+export type Source = SourceGithub;
+
+export type DestinationVercel = {
+  environment: string | null;
+  deploymentId: string | null;
+  deploymentUrl: string | null;
+  environmentName: string | null;
+  environmentTarget: string | null;
+  provider: "vercel";
+};
+
+export type Destination = DestinationVercel;
+
+export type ReleasesCreateReleaseRequest = {
+  source: SourceGithub;
+  destination: DestinationVercel | null;
+  buildId: string;
+};
+
+/** @internal */
+export type SourceGithub$Outbound = {
+  commitMessage: string;
+  branch: string;
+  commitSha: string | null;
+  provider: "github";
+};
+
+/** @internal */
+export const SourceGithub$outboundSchema: z.ZodMiniType<
+  SourceGithub$Outbound,
+  SourceGithub
+> = z.object({
+  commitMessage: z.string(),
+  branch: z.string(),
+  commitSha: z.nullable(z.string()),
+  provider: z.literal("github"),
+});
+
+export function sourceGithubToJSON(sourceGithub: SourceGithub): string {
+  return JSON.stringify(SourceGithub$outboundSchema.parse(sourceGithub));
+}
+
+/** @internal */
+export type Source$Outbound = SourceGithub$Outbound;
+
+/** @internal */
+export const Source$outboundSchema: z.ZodMiniType<Source$Outbound, Source> = z
+  .lazy(() => SourceGithub$outboundSchema);
+
+export function sourceToJSON(source: Source): string {
+  return JSON.stringify(Source$outboundSchema.parse(source));
+}
+
+/** @internal */
+export type DestinationVercel$Outbound = {
+  environment: string | null;
+  deploymentId: string | null;
+  deploymentUrl: string | null;
+  environmentName: string | null;
+  environmentTarget: string | null;
+  provider: "vercel";
+};
+
+/** @internal */
+export const DestinationVercel$outboundSchema: z.ZodMiniType<
+  DestinationVercel$Outbound,
+  DestinationVercel
+> = z.object({
+  environment: z.nullable(z.string()),
+  deploymentId: z.nullable(z.string()),
+  deploymentUrl: z.nullable(z.string()),
+  environmentName: z.nullable(z.string()),
+  environmentTarget: z.nullable(z.string()),
+  provider: z.literal("vercel"),
+});
+
+export function destinationVercelToJSON(
+  destinationVercel: DestinationVercel,
+): string {
+  return JSON.stringify(
+    DestinationVercel$outboundSchema.parse(destinationVercel),
+  );
+}
+
+/** @internal */
+export type Destination$Outbound = DestinationVercel$Outbound;
+
+/** @internal */
+export const Destination$outboundSchema: z.ZodMiniType<
+  Destination$Outbound,
+  Destination
+> = z.lazy(() => DestinationVercel$outboundSchema);
+
+export function destinationToJSON(destination: Destination): string {
+  return JSON.stringify(Destination$outboundSchema.parse(destination));
+}
+
+/** @internal */
+export type ReleasesCreateReleaseRequest$Outbound = {
+  source: SourceGithub$Outbound;
+  destination: DestinationVercel$Outbound | null;
+  buildId: string;
+};
+
+/** @internal */
+export const ReleasesCreateReleaseRequest$outboundSchema: z.ZodMiniType<
+  ReleasesCreateReleaseRequest$Outbound,
+  ReleasesCreateReleaseRequest
+> = z.object({
+  source: z.lazy(() => SourceGithub$outboundSchema),
+  destination: z.nullable(z.lazy(() => DestinationVercel$outboundSchema)),
+  buildId: z.string(),
+});
+
+export function releasesCreateReleaseRequestToJSON(
+  releasesCreateReleaseRequest: ReleasesCreateReleaseRequest,
+): string {
+  return JSON.stringify(
+    ReleasesCreateReleaseRequest$outboundSchema.parse(
+      releasesCreateReleaseRequest,
+    ),
+  );
+}

package/src/models/releases-create-release-response.ts

@@ -0,0 +1,156 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5c68faa8fa88
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import type { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import type { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type Org = {
+  id: string;
+  slug: string;
+};
+
+export type Surface = {
+  id: string;
+  slug: string;
+};
+
+export type ReleasesCreateReleaseResponseSource = {
+  id: string;
+};
+
+export type ReleasesCreateReleaseResponseDestination = {
+  id: string;
+  slug: string;
+  environment: string | null;
+};
+
+export type Build = {
+  hash: string;
+};
+
+export type ReleasesCreateReleaseResponse = {
+  org: Org;
+  surface: Surface;
+  source: ReleasesCreateReleaseResponseSource;
+  destination: ReleasesCreateReleaseResponseDestination;
+  build: Build;
+};
+
+/** @internal */
+export const Org$inboundSchema: z.ZodMiniType<Org, unknown> = z.object({
+  id: types.string(),
+  slug: types.string(),
+});
+
+export function orgFromJSON(
+  jsonString: string,
+): SafeParseResult<Org, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Org$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Org' from JSON`,
+  );
+}
+
+/** @internal */
+export const Surface$inboundSchema: z.ZodMiniType<Surface, unknown> = z.object({
+  id: types.string(),
+  slug: types.string(),
+});
+
+export function surfaceFromJSON(
+  jsonString: string,
+): SafeParseResult<Surface, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Surface$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Surface' from JSON`,
+  );
+}
+
+/** @internal */
+export const ReleasesCreateReleaseResponseSource$inboundSchema: z.ZodMiniType<
+  ReleasesCreateReleaseResponseSource,
+  unknown
+> = z.object({
+  id: types.string(),
+});
+
+export function releasesCreateReleaseResponseSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<ReleasesCreateReleaseResponseSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ReleasesCreateReleaseResponseSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReleasesCreateReleaseResponseSource' from JSON`,
+  );
+}
+
+/** @internal */
+export const ReleasesCreateReleaseResponseDestination$inboundSchema:
+  z.ZodMiniType<ReleasesCreateReleaseResponseDestination, unknown> = z.object({
+    id: types.string(),
+    slug: types.string(),
+    environment: types.nullable(types.string()),
+  });
+
+export function releasesCreateReleaseResponseDestinationFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ReleasesCreateReleaseResponseDestination,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ReleasesCreateReleaseResponseDestination$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ReleasesCreateReleaseResponseDestination' from JSON`,
+  );
+}
+
+/** @internal */
+export const Build$inboundSchema: z.ZodMiniType<Build, unknown> = z.object({
+  hash: types.string(),
+});
+
+export function buildFromJSON(
+  jsonString: string,
+): SafeParseResult<Build, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Build$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Build' from JSON`,
+  );
+}
+
+/** @internal */
+export const ReleasesCreateReleaseResponse$inboundSchema: z.ZodMiniType<
+  ReleasesCreateReleaseResponse,
+  unknown
+> = z.object({
+  org: z.lazy(() => Org$inboundSchema),
+  surface: z.lazy(() => Surface$inboundSchema),
+  source: z.lazy(() => ReleasesCreateReleaseResponseSource$inboundSchema),
+  destination: z.lazy(() =>
+    ReleasesCreateReleaseResponseDestination$inboundSchema
+  ),
+  build: z.lazy(() => Build$inboundSchema),
+});
+
+export function releasesCreateReleaseResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ReleasesCreateReleaseResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReleasesCreateReleaseResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReleasesCreateReleaseResponse' from JSON`,
+  );
+}

package/src/models/releases-upload-source-maps-request.ts

@@ -0,0 +1,151 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 25398b6a09a3
+ */
+
+import * as z from "zod/v4-mini";
+import { smartUnion } from "../types/smart-union.js";
+
+export type FileT = {
+  fileName: string;
+  content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
+};
+
+export type Metadata2 = {
+  sourceMapToGenerated: { [k: string]: string };
+  hashes: { [k: string]: string };
+};
+
+export type Metadata1 = {
+  sourceMapToGenerated: { [k: string]: string };
+  hashes: { [k: string]: string };
+};
+
+export type MetadataUnion1 = Metadata1 | string;
+
+export type MetadataUnion2 = Metadata2 | Metadata1 | string;
+
+export type ReleasesUploadSourceMapsRequest = {
+  files: Array<FileT>;
+  metadata: Metadata2 | Metadata1 | string;
+};
+
+/** @internal */
+export type FileT$Outbound = {
+  fileName: string;
+  content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
+};
+
+/** @internal */
+export const FileT$outboundSchema: z.ZodMiniType<FileT$Outbound, FileT> = z
+  .object({
+    fileName: z.string(),
+    content: z.union([
+      z.custom<ReadableStream<Uint8Array>>(x => x instanceof ReadableStream),
+      z.custom<Blob>(x => x instanceof Blob),
+      z.custom<ArrayBuffer>(x => x instanceof ArrayBuffer),
+      z.custom<Uint8Array>(x => x instanceof Uint8Array),
+    ]),
+  });
+
+export function fileToJSON(fileT: FileT): string {
+  return JSON.stringify(FileT$outboundSchema.parse(fileT));
+}
+
+/** @internal */
+export type Metadata2$Outbound = {
+  sourceMapToGenerated: { [k: string]: string };
+  hashes: { [k: string]: string };
+};
+
+/** @internal */
+export const Metadata2$outboundSchema: z.ZodMiniType<
+  Metadata2$Outbound,
+  Metadata2
+> = z.object({
+  sourceMapToGenerated: z.record(z.string(), z.string()),
+  hashes: z.record(z.string(), z.string()),
+});
+
+export function metadata2ToJSON(metadata2: Metadata2): string {
+  return JSON.stringify(Metadata2$outboundSchema.parse(metadata2));
+}
+
+/** @internal */
+export type Metadata1$Outbound = {
+  sourceMapToGenerated: { [k: string]: string };
+  hashes: { [k: string]: string };
+};
+
+/** @internal */
+export const Metadata1$outboundSchema: z.ZodMiniType<
+  Metadata1$Outbound,
+  Metadata1
+> = z.object({
+  sourceMapToGenerated: z.record(z.string(), z.string()),
+  hashes: z.record(z.string(), z.string()),
+});
+
+export function metadata1ToJSON(metadata1: Metadata1): string {
+  return JSON.stringify(Metadata1$outboundSchema.parse(metadata1));
+}
+
+/** @internal */
+export type MetadataUnion1$Outbound = Metadata1$Outbound | string;
+
+/** @internal */
+export const MetadataUnion1$outboundSchema: z.ZodMiniType<
+  MetadataUnion1$Outbound,
+  MetadataUnion1
+> = smartUnion([z.lazy(() => Metadata1$outboundSchema), z.string()]);
+
+export function metadataUnion1ToJSON(metadataUnion1: MetadataUnion1): string {
+  return JSON.stringify(MetadataUnion1$outboundSchema.parse(metadataUnion1));
+}
+
+/** @internal */
+export type MetadataUnion2$Outbound =
+  | Metadata2$Outbound
+  | Metadata1$Outbound
+  | string;
+
+/** @internal */
+export const MetadataUnion2$outboundSchema: z.ZodMiniType<
+  MetadataUnion2$Outbound,
+  MetadataUnion2
+> = smartUnion([
+  z.lazy(() => Metadata2$outboundSchema),
+  smartUnion([z.lazy(() => Metadata1$outboundSchema), z.string()]),
+]);
+
+export function metadataUnion2ToJSON(metadataUnion2: MetadataUnion2): string {
+  return JSON.stringify(MetadataUnion2$outboundSchema.parse(metadataUnion2));
+}
+
+/** @internal */
+export type ReleasesUploadSourceMapsRequest$Outbound = {
+  files: Array<FileT$Outbound>;
+  metadata: Metadata2$Outbound | Metadata1$Outbound | string;
+};
+
+/** @internal */
+export const ReleasesUploadSourceMapsRequest$outboundSchema: z.ZodMiniType<
+  ReleasesUploadSourceMapsRequest$Outbound,
+  ReleasesUploadSourceMapsRequest
+> = z.object({
+  files: z.array(z.lazy(() => FileT$outboundSchema)),
+  metadata: smartUnion([
+    z.lazy(() => Metadata2$outboundSchema),
+    smartUnion([z.lazy(() => Metadata1$outboundSchema), z.string()]),
+  ]),
+});
+
+export function releasesUploadSourceMapsRequestToJSON(
+  releasesUploadSourceMapsRequest: ReleasesUploadSourceMapsRequest,
+): string {
+  return JSON.stringify(
+    ReleasesUploadSourceMapsRequest$outboundSchema.parse(
+      releasesUploadSourceMapsRequest,
+    ),
+  );
+}