@mesadev/sdk 0.1.6 → 0.2.1

package/src/models/operations/getbyorgbyrepocontent.ts

@@ -15,8 +15,6 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 export type GetByOrgByRepoContentRequest = {
   org: string;
   repo: string;
-  cursor?: string | undefined;
-  limit?: number | undefined;
   ref?: string | undefined;
   path?: string | undefined;
   depth?: number | undefined;
@@ -71,32 +69,61 @@ export type EntryDir = {
   sha: string;
 };
 
+export type EntrySymlink = {
+  type: "symlink";
+  name: string;
+  path: string;
+  sha: string;
+  size: number;
+  executable: boolean;
+  lastCommitAt: Date | null;
+};
+
 export type EntryFile = {
   type: "file";
   name: string;
   path: string;
   sha: string;
   size: number;
+  executable: boolean;
+  lastCommitAt: Date | null;
 };
 
 export type Entry =
   | EntryFile
+  | EntrySymlink
   | EntryDir
   | discriminatedUnionTypes.Unknown<"type">;
 
 export type Dir = {
-  nextCursor: string | null;
-  hasMore: boolean;
   type: "dir";
   name: string;
   path: string;
   sha: string;
+  childCount: number;
   entries: Array<
-    EntryFile | EntryDir | discriminatedUnionTypes.Unknown<"type">
+    | EntryFile
+    | EntrySymlink
+    | EntryDir
+    | discriminatedUnionTypes.Unknown<"type">
   >;
+  nextCursor: string | null;
+  hasMore: boolean;
+};
+
+export type SymlinkBase64 = {
+  type: "symlink";
+  name: string;
+  path: string;
+  sha: string;
+  size: number;
+  encoding: "base64";
+  content: string;
+  executable: boolean;
+  lastCommitAt: Date | null;
 };
 
-export type Base64 = {
+export type FileBase64 = {
   type: "file";
   name: string;
   path: string;
@@ -104,18 +131,22 @@ export type Base64 = {
   size: number;
   encoding: "base64";
   content: string;
+  executable: boolean;
+  lastCommitAt: Date | null;
 };
 
 /**
  * Content response
  */
 export type GetByOrgByRepoContentResponseBody =
-  | Base64
+  | FileBase64
+  | SymlinkBase64
   | Dir
   | discriminatedUnionTypes.Unknown<"type">;
 
 export type GetByOrgByRepoContentResponse =
-  | Base64
+  | FileBase64
+  | SymlinkBase64
   | Dir
   | discriminatedUnionTypes.Unknown<"type">
   | ReadableStream<Uint8Array>;
@@ -124,8 +155,6 @@ export type GetByOrgByRepoContentResponse =
 export type GetByOrgByRepoContentRequest$Outbound = {
   org: string;
   repo: string;
-  cursor?: string | undefined;
-  limit?: number | undefined;
   ref?: string | undefined;
   path?: string | undefined;
   depth?: number | undefined;
@@ -138,8 +167,6 @@ export const GetByOrgByRepoContentRequest$outboundSchema: z.ZodMiniType<
 > = z.object({
   org: z.string(),
   repo: z.string(),
-  cursor: z.optional(z.string()),
-  limit: z.optional(z.int()),
   ref: z.optional(z.string()),
   path: z.optional(z.string()),
   depth: z.optional(z.int()),
@@ -326,15 +353,53 @@ export function entryDirFromJSON(
   );
 }
 
+/** @internal */
+export const EntrySymlink$inboundSchema: z.ZodMiniType<EntrySymlink, unknown> =
+  z.pipe(
+    z.object({
+      type: types.literal("symlink"),
+      name: types.string(),
+      path: types.string(),
+      sha: types.string(),
+      size: types.number(),
+      executable: types.boolean(),
+      last_commit_at: types.nullable(types.date()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "last_commit_at": "lastCommitAt",
+      });
+    }),
+  );
+
+export function entrySymlinkFromJSON(
+  jsonString: string,
+): SafeParseResult<EntrySymlink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EntrySymlink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EntrySymlink' from JSON`,
+  );
+}
+
 /** @internal */
 export const EntryFile$inboundSchema: z.ZodMiniType<EntryFile, unknown> = z
-  .object({
-    type: types.literal("file"),
-    name: types.string(),
-    path: types.string(),
-    sha: types.string(),
-    size: types.number(),
-  });
+  .pipe(
+    z.object({
+      type: types.literal("file"),
+      name: types.string(),
+      path: types.string(),
+      sha: types.string(),
+      size: types.number(),
+      executable: types.boolean(),
+      last_commit_at: types.nullable(types.date()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "last_commit_at": "lastCommitAt",
+      });
+    }),
+  );
 
 export function entryFileFromJSON(
   jsonString: string,
@@ -350,6 +415,7 @@ export function entryFileFromJSON(
 export const Entry$inboundSchema: z.ZodMiniType<Entry, unknown> =
   discriminatedUnion("type", {
     file: z.lazy(() => EntryFile$inboundSchema),
+    symlink: z.lazy(() => EntrySymlink$inboundSchema),
     dir: z.lazy(() => EntryDir$inboundSchema),
   });
 
@@ -366,19 +432,22 @@ export function entryFromJSON(
 /** @internal */
 export const Dir$inboundSchema: z.ZodMiniType<Dir, unknown> = z.pipe(
   z.object({
-    next_cursor: types.nullable(types.string()),
-    has_more: types.boolean(),
     type: types.literal("dir"),
     name: types.string(),
     path: types.string(),
     sha: types.string(),
+    child_count: types.number(),
     entries: z.array(discriminatedUnion("type", {
       file: z.lazy(() => EntryFile$inboundSchema),
+      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",
     });
@@ -396,23 +465,66 @@ export function dirFromJSON(
 }
 
 /** @internal */
-export const Base64$inboundSchema: z.ZodMiniType<Base64, unknown> = z.object({
-  type: types.literal("file"),
-  name: types.string(),
-  path: types.string(),
-  sha: types.string(),
-  size: types.number(),
-  encoding: types.literal("base64"),
-  content: types.string(),
-});
+export const SymlinkBase64$inboundSchema: z.ZodMiniType<
+  SymlinkBase64,
+  unknown
+> = z.pipe(
+  z.object({
+    type: types.literal("symlink"),
+    name: types.string(),
+    path: types.string(),
+    sha: types.string(),
+    size: types.number(),
+    encoding: types.literal("base64"),
+    content: types.string(),
+    executable: types.boolean(),
+    last_commit_at: types.nullable(types.date()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "last_commit_at": "lastCommitAt",
+    });
+  }),
+);
+
+export function symlinkBase64FromJSON(
+  jsonString: string,
+): SafeParseResult<SymlinkBase64, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SymlinkBase64$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SymlinkBase64' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileBase64$inboundSchema: z.ZodMiniType<FileBase64, unknown> = z
+  .pipe(
+    z.object({
+      type: types.literal("file"),
+      name: types.string(),
+      path: types.string(),
+      sha: types.string(),
+      size: types.number(),
+      encoding: types.literal("base64"),
+      content: types.string(),
+      executable: types.boolean(),
+      last_commit_at: types.nullable(types.date()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "last_commit_at": "lastCommitAt",
+      });
+    }),
+  );
 
-export function base64FromJSON(
+export function fileBase64FromJSON(
   jsonString: string,
-): SafeParseResult<Base64, SDKValidationError> {
+): SafeParseResult<FileBase64, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Base64$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Base64' from JSON`,
+    (x) => FileBase64$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileBase64' from JSON`,
   );
 }
 
@@ -421,7 +533,8 @@ export const GetByOrgByRepoContentResponseBody$inboundSchema: z.ZodMiniType<
   GetByOrgByRepoContentResponseBody,
   unknown
 > = discriminatedUnion("type", {
-  file: z.lazy(() => Base64$inboundSchema),
+  file: z.lazy(() => FileBase64$inboundSchema),
+  symlink: z.lazy(() => SymlinkBase64$inboundSchema),
   dir: z.lazy(() => Dir$inboundSchema),
 });
 
@@ -441,7 +554,8 @@ export const GetByOrgByRepoContentResponse$inboundSchema: z.ZodMiniType<
   unknown
 > = smartUnion([
   discriminatedUnion("type", {
-    file: z.lazy(() => Base64$inboundSchema),
+    file: z.lazy(() => FileBase64$inboundSchema),
+    symlink: z.lazy(() => SymlinkBase64$inboundSchema),
     dir: z.lazy(() => Dir$inboundSchema),
   }),
   z.custom<ReadableStream<Uint8Array>>(x => x instanceof ReadableStream),

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";