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

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 | null;
+};
+
+/** @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 | null;
+};
+
+/** @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.nullable(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 | null;
+};
+
+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.nullable(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,
+    ),
+  );
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4a9c429afffb
+ */
+
+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 ReleasesUploadSourceMapsResponse = {
+  ok: boolean;
+  processed: number;
+  message: string;
+  fileCount: number;
+};
+
+/** @internal */
+export const ReleasesUploadSourceMapsResponse$inboundSchema: z.ZodMiniType<
+  ReleasesUploadSourceMapsResponse,
+  unknown
+> = z.object({
+  ok: types.boolean(),
+  processed: types.number(),
+  message: types.string(),
+  fileCount: types.number(),
+});
+
+export function releasesUploadSourceMapsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ReleasesUploadSourceMapsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReleasesUploadSourceMapsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReleasesUploadSourceMapsResponse' from JSON`,
+  );
+}

package/src/models/session-create-session-request.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c98522375a54
+ */
+
+import * as z from "zod/v4-mini";
+
+export type SessionCreateSessionRequest = {
+  sessionId: string;
+  visitorId: string | null;
+};
+
+/** @internal */
+export type SessionCreateSessionRequest$Outbound = {
+  sessionId: string;
+  visitorId: string | null;
+};
+
+/** @internal */
+export const SessionCreateSessionRequest$outboundSchema: z.ZodMiniType<
+  SessionCreateSessionRequest$Outbound,
+  SessionCreateSessionRequest
+> = z.object({
+  sessionId: z.string(),
+  visitorId: z.nullable(z.string()),
+});
+
+export function sessionCreateSessionRequestToJSON(
+  sessionCreateSessionRequest: SessionCreateSessionRequest,
+): string {
+  return JSON.stringify(
+    SessionCreateSessionRequest$outboundSchema.parse(
+      sessionCreateSessionRequest,
+    ),
+  );
+}

package/src/models/session-identify-session-request.ts

@@ -0,0 +1,64 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 61824b7098b2
+ */
+
+import * as z from "zod/v4-mini";
+
+export type Traits = {};
+
+export type SessionIdentifySessionRequest = {
+  name?: string | undefined;
+  sessionId: string;
+  visitorId: string | null;
+  identifier: string;
+  email?: string | undefined;
+  avatar?: string | undefined;
+  traits?: Traits | undefined;
+};
+
+/** @internal */
+export type Traits$Outbound = {};
+
+/** @internal */
+export const Traits$outboundSchema: z.ZodMiniType<Traits$Outbound, Traits> = z
+  .object({});
+
+export function traitsToJSON(traits: Traits): string {
+  return JSON.stringify(Traits$outboundSchema.parse(traits));
+}
+
+/** @internal */
+export type SessionIdentifySessionRequest$Outbound = {
+  name?: string | undefined;
+  sessionId: string;
+  visitorId: string | null;
+  identifier: string;
+  email?: string | undefined;
+  avatar?: string | undefined;
+  traits?: Traits$Outbound | undefined;
+};
+
+/** @internal */
+export const SessionIdentifySessionRequest$outboundSchema: z.ZodMiniType<
+  SessionIdentifySessionRequest$Outbound,
+  SessionIdentifySessionRequest
+> = z.object({
+  name: z.optional(z.string()),
+  sessionId: z.string(),
+  visitorId: z.nullable(z.string()),
+  identifier: z.string(),
+  email: z.optional(z.string()),
+  avatar: z.optional(z.string()),
+  traits: z.optional(z.lazy(() => Traits$outboundSchema)),
+});
+
+export function sessionIdentifySessionRequestToJSON(
+  sessionIdentifySessionRequest: SessionIdentifySessionRequest,
+): string {
+  return JSON.stringify(
+    SessionIdentifySessionRequest$outboundSchema.parse(
+      sessionIdentifySessionRequest,
+    ),
+  );
+}

package/src/models/session-session-response.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 84d0fc008684
+ */
+
+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 SessionSessionResponse = {
+  ok: boolean;
+};
+
+/** @internal */
+export const SessionSessionResponse$inboundSchema: z.ZodMiniType<
+  SessionSessionResponse,
+  unknown
+> = z.object({
+  ok: types.boolean(),
+});
+
+export function sessionSessionResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SessionSessionResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SessionSessionResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SessionSessionResponse' from JSON`,
+  );
+}

package/src/sdk/releases.ts

@@ -4,29 +4,32 @@
  */
 
 import { releasesCreateRelease } from "../funcs/releases-create-release.js";
-import { ClientSDK, RequestOptions } from "../lib/sdks.js";
-import {
-  CreateReleaseRequest,
-  CreateReleaseResponse,
-  CreateReleaseSecurity,
-} from "../models/operations/create-release.js";
+import { releasesUploadSourceMaps } from "../funcs/releases-upload-source-maps.js";
+import { ClientSDK, type RequestOptions } from "../lib/sdks.js";
+import type { UploadSourceMapsRequest } from "../models/operations/upload-source-maps.js";
+import type { ReleasesCreateReleaseRequest } from "../models/releases-create-release-request.js";
+import type { ReleasesCreateReleaseResponse } from "../models/releases-create-release-response.js";
+import type { ReleasesUploadSourceMapsResponse } from "../models/releases-upload-source-maps-response.js";
 import { unwrapAsync } from "../types/fp.js";
 
 export class Releases extends ClientSDK {
-  /**
-   * Create release
-   *
-   * @remarks
-   * Create or update a release for source map uploads
-   */
   async createRelease(
-    security: CreateReleaseSecurity,
-    request: CreateReleaseRequest,
+    request: ReleasesCreateReleaseRequest,
     options?: RequestOptions,
-  ): Promise<CreateReleaseResponse> {
+  ): Promise<ReleasesCreateReleaseResponse> {
     return unwrapAsync(releasesCreateRelease(
       this,
-      security,
+      request,
+      options,
+    ));
+  }
+
+  async uploadSourceMaps(
+    request: UploadSourceMapsRequest,
+    options?: RequestOptions,
+  ): Promise<ReleasesUploadSourceMapsResponse> {
+    return unwrapAsync(releasesUploadSourceMaps(
+      this,
       request,
       options,
     ));