@mesadev/sdk 0.1.7 → 0.2.1

package/src/models/operations/getbyorgbyrepo.ts

@@ -8,6 +8,7 @@ import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetByOrgByRepoRequest = {
@@ -60,17 +61,17 @@ export type GetByOrgByRepoBadRequestError = {
 /**
  * Conflict resolution strategy. "none" means sync will fail on conflicts.
  */
-export const GetByOrgByRepoResolutionStrategy = {
+export const ResolutionStrategySyncing = {
   None: "none",
 } as const;
 /**
  * Conflict resolution strategy. "none" means sync will fail on conflicts.
  */
-export type GetByOrgByRepoResolutionStrategy = ClosedEnum<
-  typeof GetByOrgByRepoResolutionStrategy
+export type ResolutionStrategySyncing = ClosedEnum<
+  typeof ResolutionStrategySyncing
 >;
 
-export type GetByOrgByRepoAutosync = {
+export type AutosyncSyncing = {
   type: "poll";
   /**
    * Polling period in seconds
@@ -79,10 +80,10 @@ export type GetByOrgByRepoAutosync = {
   /**
    * Conflict resolution strategy. "none" means sync will fail on conflicts.
    */
-  resolutionStrategy: GetByOrgByRepoResolutionStrategy;
+  resolutionStrategy: ResolutionStrategySyncing;
 };
 
-export type GetByOrgByRepoUpstream = {
+export type UpstreamSyncing = {
   /**
    * URL of the upstream repository
    */
@@ -90,7 +91,7 @@ export type GetByOrgByRepoUpstream = {
   /**
    * Automatic sync configuration, if enabled
    */
-  autosync: GetByOrgByRepoAutosync | null;
+  autosync: AutosyncSyncing | null;
   /**
    * Timestamp of the last sync attempt
    */
@@ -103,25 +104,111 @@ export type GetByOrgByRepoUpstream = {
    * Error message from the last failed sync attempt
    */
   lastSyncError: string | null;
+  /**
+   * Whether this upstream has an authentication credential configured
+   */
+  hasCredential: boolean;
+  /**
+   * The host the credential is scoped to (e.g. "github.com")
+   */
+  credentialHost: string | null;
+};
+
+/**
+ * Repository is being synchronized
+ */
+export type GetByOrgByRepoResponseBodySyncing = {
+  id: string;
+  org: string;
+  name: string;
+  defaultBranch: string;
+  headSha: string | null;
+  sizeBytes: number;
+  createdAt: string;
+  /**
+   * Optionally add an upstream repository. You can configure automatic syncing from the upstream repository.
+   */
+  upstream: UpstreamSyncing | null;
+  status: "syncing";
+};
+
+/**
+ * Conflict resolution strategy. "none" means sync will fail on conflicts.
+ */
+export const GetByOrgByRepoResolutionStrategyResponseBody = {
+  None: "none",
+} as const;
+/**
+ * Conflict resolution strategy. "none" means sync will fail on conflicts.
+ */
+export type GetByOrgByRepoResolutionStrategyResponseBody = ClosedEnum<
+  typeof GetByOrgByRepoResolutionStrategyResponseBody
+>;
+
+export type GetByOrgByRepoAutosyncResponseBody = {
+  type: "poll";
+  /**
+   * Polling period in seconds
+   */
+  period: number;
+  /**
+   * Conflict resolution strategy. "none" means sync will fail on conflicts.
+   */
+  resolutionStrategy: GetByOrgByRepoResolutionStrategyResponseBody;
+};
+
+export type GetByOrgByRepoUpstreamResponseBody = {
+  /**
+   * URL of the upstream repository
+   */
+  uri: string;
+  /**
+   * Automatic sync configuration, if enabled
+   */
+  autosync: GetByOrgByRepoAutosyncResponseBody | null;
+  /**
+   * Timestamp of the last sync attempt
+   */
+  lastSyncAttempt: Date | null;
+  /**
+   * Timestamp of the last successful sync
+   */
+  lastSyncSuccess: Date | null;
+  /**
+   * Error message from the last failed sync attempt
+   */
+  lastSyncError: string | null;
+  /**
+   * Whether this upstream has an authentication credential configured
+   */
+  hasCredential: boolean;
+  /**
+   * The host the credential is scoped to (e.g. "github.com")
+   */
+  credentialHost: string | null;
 };
 
 /**
  * Repository
  */
-export type GetByOrgByRepoResponse = {
+export type GetByOrgByRepoResponseBody = {
   id: string;
   org: string;
   name: string;
   defaultBranch: string;
+  headSha: string | null;
   sizeBytes: number;
-  lastPushAt: string | null;
   createdAt: string;
   /**
    * Optionally add an upstream repository. You can configure automatic syncing from the upstream repository.
    */
-  upstream: GetByOrgByRepoUpstream | null;
+  upstream: GetByOrgByRepoUpstreamResponseBody | null;
 };
 
+export type GetByOrgByRepoResponse =
+  | GetByOrgByRepoResponseBodySyncing
+  | GetByOrgByRepoResponseBody;
+
 /** @internal */
 export type GetByOrgByRepoRequest$Outbound = {
   org: string;
@@ -285,19 +372,19 @@ export function getByOrgByRepoBadRequestErrorFromJSON(
 }
 
 /** @internal */
-export const GetByOrgByRepoResolutionStrategy$inboundSchema: z.ZodMiniEnum<
-  typeof GetByOrgByRepoResolutionStrategy
-> = z.enum(GetByOrgByRepoResolutionStrategy);
+export const ResolutionStrategySyncing$inboundSchema: z.ZodMiniEnum<
+  typeof ResolutionStrategySyncing
+> = z.enum(ResolutionStrategySyncing);
 
 /** @internal */
-export const GetByOrgByRepoAutosync$inboundSchema: z.ZodMiniType<
-  GetByOrgByRepoAutosync,
+export const AutosyncSyncing$inboundSchema: z.ZodMiniType<
+  AutosyncSyncing,
   unknown
 > = z.pipe(
   z.object({
     type: types.literal("poll"),
     period: types.number(),
-    resolution_strategy: GetByOrgByRepoResolutionStrategy$inboundSchema,
+    resolution_strategy: ResolutionStrategySyncing$inboundSchema,
   }),
   z.transform((v) => {
     return remap$(v, {
@@ -306,52 +393,163 @@ export const GetByOrgByRepoAutosync$inboundSchema: z.ZodMiniType<
   }),
 );
 
-export function getByOrgByRepoAutosyncFromJSON(
+export function autosyncSyncingFromJSON(
   jsonString: string,
-): SafeParseResult<GetByOrgByRepoAutosync, SDKValidationError> {
+): SafeParseResult<AutosyncSyncing, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetByOrgByRepoAutosync$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetByOrgByRepoAutosync' from JSON`,
+    (x) => AutosyncSyncing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AutosyncSyncing' from JSON`,
   );
 }
 
 /** @internal */
-export const GetByOrgByRepoUpstream$inboundSchema: z.ZodMiniType<
-  GetByOrgByRepoUpstream,
+export const UpstreamSyncing$inboundSchema: z.ZodMiniType<
+  UpstreamSyncing,
+  unknown
+> = z.pipe(
+  z.object({
+    uri: types.string(),
+    autosync: types.nullable(z.lazy(() => AutosyncSyncing$inboundSchema)),
+    last_sync_attempt: types.nullable(types.date()),
+    last_sync_success: types.nullable(types.date()),
+    last_sync_error: types.nullable(types.string()),
+    has_credential: types.boolean(),
+    credential_host: types.nullable(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "last_sync_attempt": "lastSyncAttempt",
+      "last_sync_success": "lastSyncSuccess",
+      "last_sync_error": "lastSyncError",
+      "has_credential": "hasCredential",
+      "credential_host": "credentialHost",
+    });
+  }),
+);
+
+export function upstreamSyncingFromJSON(
+  jsonString: string,
+): SafeParseResult<UpstreamSyncing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpstreamSyncing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpstreamSyncing' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetByOrgByRepoResponseBodySyncing$inboundSchema: z.ZodMiniType<
+  GetByOrgByRepoResponseBodySyncing,
+  unknown
+> = z.pipe(
+  z.object({
+    id: types.string(),
+    org: types.string(),
+    name: types.string(),
+    default_branch: types.string(),
+    head_sha: types.nullable(types.string()),
+    size_bytes: types.number(),
+    created_at: types.string(),
+    upstream: types.nullable(z.lazy(() => UpstreamSyncing$inboundSchema)),
+    status: types.literal("syncing"),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "default_branch": "defaultBranch",
+      "head_sha": "headSha",
+      "size_bytes": "sizeBytes",
+      "created_at": "createdAt",
+    });
+  }),
+);
+
+export function getByOrgByRepoResponseBodySyncingFromJSON(
+  jsonString: string,
+): SafeParseResult<GetByOrgByRepoResponseBodySyncing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetByOrgByRepoResponseBodySyncing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetByOrgByRepoResponseBodySyncing' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetByOrgByRepoResolutionStrategyResponseBody$inboundSchema:
+  z.ZodMiniEnum<typeof GetByOrgByRepoResolutionStrategyResponseBody> = z.enum(
+    GetByOrgByRepoResolutionStrategyResponseBody,
+  );
+
+/** @internal */
+export const GetByOrgByRepoAutosyncResponseBody$inboundSchema: z.ZodMiniType<
+  GetByOrgByRepoAutosyncResponseBody,
+  unknown
+> = z.pipe(
+  z.object({
+    type: types.literal("poll"),
+    period: types.number(),
+    resolution_strategy:
+      GetByOrgByRepoResolutionStrategyResponseBody$inboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "resolution_strategy": "resolutionStrategy",
+    });
+  }),
+);
+
+export function getByOrgByRepoAutosyncResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetByOrgByRepoAutosyncResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetByOrgByRepoAutosyncResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetByOrgByRepoAutosyncResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetByOrgByRepoUpstreamResponseBody$inboundSchema: z.ZodMiniType<
+  GetByOrgByRepoUpstreamResponseBody,
   unknown
 > = z.pipe(
   z.object({
     uri: types.string(),
     autosync: types.nullable(
-      z.lazy(() => GetByOrgByRepoAutosync$inboundSchema),
+      z.lazy(() => GetByOrgByRepoAutosyncResponseBody$inboundSchema),
     ),
     last_sync_attempt: types.nullable(types.date()),
     last_sync_success: types.nullable(types.date()),
     last_sync_error: types.nullable(types.string()),
+    has_credential: types.boolean(),
+    credential_host: types.nullable(types.string()),
   }),
   z.transform((v) => {
     return remap$(v, {
       "last_sync_attempt": "lastSyncAttempt",
       "last_sync_success": "lastSyncSuccess",
       "last_sync_error": "lastSyncError",
+      "has_credential": "hasCredential",
+      "credential_host": "credentialHost",
     });
   }),
 );
 
-export function getByOrgByRepoUpstreamFromJSON(
+export function getByOrgByRepoUpstreamResponseBodyFromJSON(
   jsonString: string,
-): SafeParseResult<GetByOrgByRepoUpstream, SDKValidationError> {
+): SafeParseResult<GetByOrgByRepoUpstreamResponseBody, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetByOrgByRepoUpstream$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetByOrgByRepoUpstream' from JSON`,
+    (x) =>
+      GetByOrgByRepoUpstreamResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetByOrgByRepoUpstreamResponseBody' from JSON`,
   );
 }
 
 /** @internal */
-export const GetByOrgByRepoResponse$inboundSchema: z.ZodMiniType<
-  GetByOrgByRepoResponse,
+export const GetByOrgByRepoResponseBody$inboundSchema: z.ZodMiniType<
+  GetByOrgByRepoResponseBody,
   unknown
 > = z.pipe(
   z.object({
@@ -359,23 +557,42 @@ export const GetByOrgByRepoResponse$inboundSchema: z.ZodMiniType<
     org: types.string(),
     name: types.string(),
     default_branch: types.string(),
+    head_sha: types.nullable(types.string()),
     size_bytes: types.number(),
-    last_push_at: types.nullable(types.string()),
     created_at: types.string(),
     upstream: types.nullable(
-      z.lazy(() => GetByOrgByRepoUpstream$inboundSchema),
+      z.lazy(() => GetByOrgByRepoUpstreamResponseBody$inboundSchema),
     ),
   }),
   z.transform((v) => {
     return remap$(v, {
       "default_branch": "defaultBranch",
+      "head_sha": "headSha",
       "size_bytes": "sizeBytes",
-      "last_push_at": "lastPushAt",
       "created_at": "createdAt",
     });
   }),
 );
 
+export function getByOrgByRepoResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetByOrgByRepoResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetByOrgByRepoResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetByOrgByRepoResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetByOrgByRepoResponse$inboundSchema: z.ZodMiniType<
+  GetByOrgByRepoResponse,
+  unknown
+> = smartUnion([
+  z.lazy(() => GetByOrgByRepoResponseBodySyncing$inboundSchema),
+  z.lazy(() => GetByOrgByRepoResponseBody$inboundSchema),
+]);
+
 export function getByOrgByRepoResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<GetByOrgByRepoResponse, SDKValidationError> {

package/src/models/operations/getbyorgbyrepocontent.ts

@@ -107,6 +107,8 @@ export type Dir = {
     | EntryDir
     | discriminatedUnionTypes.Unknown<"type">
   >;
+  nextCursor: string | null;
+  hasMore: boolean;
 };
 
 export type SymlinkBase64 = {
@@ -440,10 +442,14 @@ export const Dir$inboundSchema: z.ZodMiniType<Dir, unknown> = z.pipe(
       symlink: z.lazy(() => EntrySymlink$inboundSchema),
       dir: z.lazy(() => EntryDir$inboundSchema),
     })),
+    next_cursor: types.nullable(types.string()),
+    has_more: types.boolean(),
   }),
   z.transform((v) => {
     return remap$(v, {
       "child_count": "childCount",
+      "next_cursor": "nextCursor",
+      "has_more": "hasMore",
     });
   }),
 );

package/src/models/operations/getbyorgbyreposync.ts

@@ -69,6 +69,13 @@ export type StatusError = {
   message: string;
 };
 
+/**
+ * A sync is currently in progress.
+ */
+export type StatusSyncing = {
+  type: "syncing";
+};
+
 /**
  * The last sync was successful.
  */
@@ -81,6 +88,7 @@ export type StatusOk = {
  */
 export type Status =
   | StatusOk
+  | StatusSyncing
   | StatusError
   | discriminatedUnionTypes.Unknown<"type">;
 
@@ -99,7 +107,11 @@ export type GetByOrgByRepoSyncResponse = {
   /**
    * What the status of the last sync was.
    */
-  status: StatusOk | StatusError | discriminatedUnionTypes.Unknown<"type">;
+  status:
+    | StatusOk
+    | StatusSyncing
+    | StatusError
+    | discriminatedUnionTypes.Unknown<"type">;
 };
 
 /** @internal */
@@ -290,6 +302,24 @@ export function statusErrorFromJSON(
   );
 }
 
+/** @internal */
+export const StatusSyncing$inboundSchema: z.ZodMiniType<
+  StatusSyncing,
+  unknown
+> = z.object({
+  type: types.literal("syncing"),
+});
+
+export function statusSyncingFromJSON(
+  jsonString: string,
+): SafeParseResult<StatusSyncing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StatusSyncing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StatusSyncing' from JSON`,
+  );
+}
+
 /** @internal */
 export const StatusOk$inboundSchema: z.ZodMiniType<StatusOk, unknown> = z
   .object({
@@ -310,6 +340,7 @@ export function statusOkFromJSON(
 export const Status$inboundSchema: z.ZodMiniType<Status, unknown> =
   discriminatedUnion("type", {
     ok: z.lazy(() => StatusOk$inboundSchema),
+    syncing: z.lazy(() => StatusSyncing$inboundSchema),
     error: z.lazy(() => StatusError$inboundSchema),
   });
 
@@ -333,6 +364,7 @@ export const GetByOrgByRepoSyncResponse$inboundSchema: z.ZodMiniType<
     last_sync_success: types.nullable(types.date()),
     status: discriminatedUnion("type", {
       ok: z.lazy(() => StatusOk$inboundSchema),
+      syncing: z.lazy(() => StatusSyncing$inboundSchema),
       error: z.lazy(() => StatusError$inboundSchema),
     }),
   }),

package/src/models/operations/getbyorgrepos.ts

@@ -104,6 +104,14 @@ export type GetByOrgReposUpstream = {
    * Error message from the last failed sync attempt
    */
   lastSyncError: string | null;
+  /**
+   * Whether this upstream has an authentication credential configured
+   */
+  hasCredential: boolean;
+  /**
+   * The host the credential is scoped to (e.g. "github.com")
+   */
+  credentialHost: string | null;
 };
 
 export type Repo = {
@@ -111,8 +119,8 @@ export type Repo = {
   org: string;
   name: string;
   defaultBranch: string;
+  headSha: string | null;
   sizeBytes: number;
-  lastPushAt: string | null;
   createdAt: string;
   /**
    * Optionally add an upstream repository. You can configure automatic syncing from the upstream repository.
@@ -342,12 +350,16 @@ export const GetByOrgReposUpstream$inboundSchema: z.ZodMiniType<
     last_sync_attempt: types.nullable(types.date()),
     last_sync_success: types.nullable(types.date()),
     last_sync_error: types.nullable(types.string()),
+    has_credential: types.boolean(),
+    credential_host: types.nullable(types.string()),
   }),
   z.transform((v) => {
     return remap$(v, {
       "last_sync_attempt": "lastSyncAttempt",
       "last_sync_success": "lastSyncSuccess",
       "last_sync_error": "lastSyncError",
+      "has_credential": "hasCredential",
+      "credential_host": "credentialHost",
     });
   }),
 );
@@ -369,16 +381,16 @@ export const Repo$inboundSchema: z.ZodMiniType<Repo, unknown> = z.pipe(
     org: types.string(),
     name: types.string(),
     default_branch: types.string(),
+    head_sha: types.nullable(types.string()),
     size_bytes: types.number(),
-    last_push_at: types.nullable(types.string()),
     created_at: types.string(),
     upstream: types.nullable(z.lazy(() => GetByOrgReposUpstream$inboundSchema)),
   }),
   z.transform((v) => {
     return remap$(v, {
       "default_branch": "defaultBranch",
+      "head_sha": "headSha",
       "size_bytes": "sizeBytes",
-      "last_push_at": "lastPushAt",
       "created_at": "createdAt",
     });
   }),

package/src/models/operations/index.ts

@@ -24,6 +24,9 @@ export * from "./postbyorgapikeys.js";
 export * from "./postbyorgbyrepoanalyticsrefresh.js";
 export * from "./postbyorgbyrepobranches.js";
 export * from "./postbyorgbyrepocommits.js";
+export * from "./postbyorgbyrepolfsobjects.js";
+export * from "./postbyorgbyrepolfsobjectsdownload.js";
+export * from "./postbyorgbyrepomergebybase.js";
 export * from "./postbyorgbyreposync.js";
 export * from "./postbyorgbyrepowebhooks.js";
 export * from "./postbyorgrepos.js";