@mesadev/sdk 0.1.0 → 0.1.3

package/src/models/errors/postorgrepoanalyticsrefresh.ts

@@ -0,0 +1,360 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as operations from "../operations/index.js";
+import { MesaError } from "./mesaerror.js";
+
+/**
+ * Internal error
+ */
+export type PostOrgRepoAnalyticsRefreshInternalServerErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshInternalServerErrorError;
+};
+
+/**
+ * Internal error
+ */
+export class PostOrgRepoAnalyticsRefreshInternalServerError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshInternalServerErrorError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshInternalServerErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshInternalServerError";
+  }
+}
+
+/**
+ * Conflict
+ */
+export type PostOrgRepoAnalyticsRefreshConflictErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshConflictError;
+};
+
+/**
+ * Conflict
+ */
+export class PostOrgRepoAnalyticsRefreshConflictError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshConflictError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshConflictErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshConflictErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshConflictError";
+  }
+}
+
+/**
+ * Not acceptable
+ */
+export type PostOrgRepoAnalyticsRefreshNotAcceptableErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshNotAcceptableError;
+};
+
+/**
+ * Not acceptable
+ */
+export class PostOrgRepoAnalyticsRefreshNotAcceptableError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshNotAcceptableError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshNotAcceptableErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshNotAcceptableErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshNotAcceptableError";
+  }
+}
+
+/**
+ * Not found
+ */
+export type PostOrgRepoAnalyticsRefreshNotFoundErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshNotFoundError;
+};
+
+/**
+ * Not found
+ */
+export class PostOrgRepoAnalyticsRefreshNotFoundError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshNotFoundError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshNotFoundErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshNotFoundErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshNotFoundError";
+  }
+}
+
+/**
+ * Forbidden
+ */
+export type PostOrgRepoAnalyticsRefreshForbiddenErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshForbiddenError;
+};
+
+/**
+ * Forbidden
+ */
+export class PostOrgRepoAnalyticsRefreshForbiddenError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshForbiddenError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshForbiddenErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshForbiddenErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshForbiddenError";
+  }
+}
+
+/**
+ * Unauthorized
+ */
+export type PostOrgRepoAnalyticsRefreshUnauthorizedErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshUnauthorizedError;
+};
+
+/**
+ * Unauthorized
+ */
+export class PostOrgRepoAnalyticsRefreshUnauthorizedError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshUnauthorizedError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshUnauthorizedErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshUnauthorizedErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshUnauthorizedError";
+  }
+}
+
+/**
+ * Invalid request
+ */
+export type PostOrgRepoAnalyticsRefreshBadRequestErrorData = {
+  error: operations.PostOrgRepoAnalyticsRefreshBadRequestError;
+};
+
+/**
+ * Invalid request
+ */
+export class PostOrgRepoAnalyticsRefreshBadRequestError extends MesaError {
+  error: operations.PostOrgRepoAnalyticsRefreshBadRequestError;
+
+  /** The original data that was passed to this error instance. */
+  data$: PostOrgRepoAnalyticsRefreshBadRequestErrorData;
+
+  constructor(
+    err: PostOrgRepoAnalyticsRefreshBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "PostOrgRepoAnalyticsRefreshBadRequestError";
+  }
+}
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshInternalServerError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshInternalServerError, unknown> = z
+    .pipe(
+      z.object({
+        error: z.lazy(() =>
+          operations
+            .PostOrgRepoAnalyticsRefreshInternalServerErrorError$inboundSchema
+        ),
+        request$: z.custom<Request>(x => x instanceof Request),
+        response$: z.custom<Response>(x => x instanceof Response),
+        body$: z.string(),
+      }),
+      z.transform((v) => {
+        return new PostOrgRepoAnalyticsRefreshInternalServerError(v, {
+          request: v.request$,
+          response: v.response$,
+          body: v.body$,
+        });
+      }),
+    );
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshConflictError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshConflictError, unknown> = z.pipe(
+    z.object({
+      error: z.lazy(() =>
+        operations.PostOrgRepoAnalyticsRefreshConflictError$inboundSchema
+      ),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      return new PostOrgRepoAnalyticsRefreshConflictError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshNotAcceptableError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshNotAcceptableError, unknown> = z
+    .pipe(
+      z.object({
+        error: z.lazy(() =>
+          operations.PostOrgRepoAnalyticsRefreshNotAcceptableError$inboundSchema
+        ),
+        request$: z.custom<Request>(x => x instanceof Request),
+        response$: z.custom<Response>(x => x instanceof Response),
+        body$: z.string(),
+      }),
+      z.transform((v) => {
+        return new PostOrgRepoAnalyticsRefreshNotAcceptableError(v, {
+          request: v.request$,
+          response: v.response$,
+          body: v.body$,
+        });
+      }),
+    );
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshNotFoundError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshNotFoundError, unknown> = z.pipe(
+    z.object({
+      error: z.lazy(() =>
+        operations.PostOrgRepoAnalyticsRefreshNotFoundError$inboundSchema
+      ),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      return new PostOrgRepoAnalyticsRefreshNotFoundError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshForbiddenError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshForbiddenError, unknown> = z.pipe(
+    z.object({
+      error: z.lazy(() =>
+        operations.PostOrgRepoAnalyticsRefreshForbiddenError$inboundSchema
+      ),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      return new PostOrgRepoAnalyticsRefreshForbiddenError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshUnauthorizedError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshUnauthorizedError, unknown> = z.pipe(
+    z.object({
+      error: z.lazy(() =>
+        operations.PostOrgRepoAnalyticsRefreshUnauthorizedError$inboundSchema
+      ),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      return new PostOrgRepoAnalyticsRefreshUnauthorizedError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );
+
+/** @internal */
+export const PostOrgRepoAnalyticsRefreshBadRequestError$inboundSchema:
+  z.ZodMiniType<PostOrgRepoAnalyticsRefreshBadRequestError, unknown> = z.pipe(
+    z.object({
+      error: z.lazy(() =>
+        operations.PostOrgRepoAnalyticsRefreshBadRequestError$inboundSchema
+      ),
+      request$: z.custom<Request>(x => x instanceof Request),
+      response$: z.custom<Response>(x => x instanceof Response),
+      body$: z.string(),
+    }),
+    z.transform((v) => {
+      return new PostOrgRepoAnalyticsRefreshBadRequestError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    }),
+  );

package/src/models/operations/getorgrepoagentblame.ts

@@ -0,0 +1,338 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type GetOrgRepoAgentblameRequest = {
+  org: string;
+  repo: string;
+  base: string;
+  head: string;
+};
+
+export type GetOrgRepoAgentblameInternalServerErrorError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type GetOrgRepoAgentblameConflictError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type GetOrgRepoAgentblameNotAcceptableError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type GetOrgRepoAgentblameNotFoundError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type GetOrgRepoAgentblameForbiddenError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type GetOrgRepoAgentblameUnauthorizedError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type GetOrgRepoAgentblameBadRequestError = {
+  code: string;
+  message: string;
+  details?: { [k: string]: any } | undefined;
+};
+
+export type Attribution = {
+  lineNumber: number;
+  provider: string;
+  model: string | null;
+  confidence: number;
+  matchType: string;
+};
+
+export type GetOrgRepoAgentblameStats = {
+  totalLines: number;
+  aiLines: number;
+  humanLines: number;
+  aiPercentage: number;
+};
+
+/**
+ * Attribution data
+ */
+export type GetOrgRepoAgentblameResponse = {
+  attributions: { [k: string]: Array<Attribution> };
+  stats: GetOrgRepoAgentblameStats;
+};
+
+/** @internal */
+export type GetOrgRepoAgentblameRequest$Outbound = {
+  org: string;
+  repo: string;
+  base: string;
+  head: string;
+};
+
+/** @internal */
+export const GetOrgRepoAgentblameRequest$outboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameRequest$Outbound,
+  GetOrgRepoAgentblameRequest
+> = z.object({
+  org: z.string(),
+  repo: z.string(),
+  base: z.string(),
+  head: z.string(),
+});
+
+export function getOrgRepoAgentblameRequestToJSON(
+  getOrgRepoAgentblameRequest: GetOrgRepoAgentblameRequest,
+): string {
+  return JSON.stringify(
+    GetOrgRepoAgentblameRequest$outboundSchema.parse(
+      getOrgRepoAgentblameRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameInternalServerErrorError$inboundSchema:
+  z.ZodMiniType<GetOrgRepoAgentblameInternalServerErrorError, unknown> = z
+    .object({
+      code: types.string(),
+      message: types.string(),
+      details: types.optional(z.record(z.string(), z.any())),
+    });
+
+export function getOrgRepoAgentblameInternalServerErrorErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetOrgRepoAgentblameInternalServerErrorError,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgRepoAgentblameInternalServerErrorError$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetOrgRepoAgentblameInternalServerErrorError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameConflictError$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameConflictError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function getOrgRepoAgentblameConflictErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameConflictError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgRepoAgentblameConflictError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameConflictError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameNotAcceptableError$inboundSchema:
+  z.ZodMiniType<GetOrgRepoAgentblameNotAcceptableError, unknown> = z.object({
+    code: types.string(),
+    message: types.string(),
+    details: types.optional(z.record(z.string(), z.any())),
+  });
+
+export function getOrgRepoAgentblameNotAcceptableErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameNotAcceptableError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgRepoAgentblameNotAcceptableError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameNotAcceptableError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameNotFoundError$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameNotFoundError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function getOrgRepoAgentblameNotFoundErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameNotFoundError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgRepoAgentblameNotFoundError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameNotFoundError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameForbiddenError$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameForbiddenError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function getOrgRepoAgentblameForbiddenErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameForbiddenError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgRepoAgentblameForbiddenError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameForbiddenError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameUnauthorizedError$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameUnauthorizedError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function getOrgRepoAgentblameUnauthorizedErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameUnauthorizedError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgRepoAgentblameUnauthorizedError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameUnauthorizedError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameBadRequestError$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameBadRequestError,
+  unknown
+> = z.object({
+  code: types.string(),
+  message: types.string(),
+  details: types.optional(z.record(z.string(), z.any())),
+});
+
+export function getOrgRepoAgentblameBadRequestErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameBadRequestError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetOrgRepoAgentblameBadRequestError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameBadRequestError' from JSON`,
+  );
+}
+
+/** @internal */
+export const Attribution$inboundSchema: z.ZodMiniType<Attribution, unknown> = z
+  .pipe(
+    z.object({
+      lineNumber: types.number(),
+      provider: types.string(),
+      model: types.nullable(types.string()),
+      confidence: types.number(),
+      match_type: types.string(),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "match_type": "matchType",
+      });
+    }),
+  );
+
+export function attributionFromJSON(
+  jsonString: string,
+): SafeParseResult<Attribution, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Attribution$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Attribution' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameStats$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameStats,
+  unknown
+> = z.pipe(
+  z.object({
+    total_lines: types.number(),
+    ai_lines: types.number(),
+    human_lines: types.number(),
+    ai_percentage: types.number(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "total_lines": "totalLines",
+      "ai_lines": "aiLines",
+      "human_lines": "humanLines",
+      "ai_percentage": "aiPercentage",
+    });
+  }),
+);
+
+export function getOrgRepoAgentblameStatsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameStats, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgRepoAgentblameStats$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameStats' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgRepoAgentblameResponse$inboundSchema: z.ZodMiniType<
+  GetOrgRepoAgentblameResponse,
+  unknown
+> = z.object({
+  attributions: z.record(
+    z.string(),
+    z.array(z.lazy(() => Attribution$inboundSchema)),
+  ),
+  stats: z.lazy(() => GetOrgRepoAgentblameStats$inboundSchema),
+});
+
+export function getOrgRepoAgentblameResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgRepoAgentblameResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgRepoAgentblameResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgRepoAgentblameResponse' from JSON`,
+  );
+}