@boatdev/sdk 1.7.0 → 1.9.0

package/src/http2-fetch.ts

@@ -0,0 +1,179 @@
+// The SDK's default fetch. On Node it sends every request to an https origin over
+// ONE shared HTTP/2 connection. Node's global fetch speaks HTTP/1.1 only, so N
+// concurrent calls opened N TLS connections: a burst of 200 calls from a laptop
+// made 200 handshakes (measured 2026-10-08), and 250 creates arrived at the API
+// over 8-14 s. Elsewhere (browsers, Deno, Bun, an origin without HTTP/2), and for
+// any body this does not handle, it is the global fetch.
+// Pass `fetchApi` in the Configuration to use your own fetch instead.
+
+type Session = {
+  closed: boolean;
+  destroyed: boolean;
+  request(headers: Record<string, string>, options?: { endStream?: boolean }): any;
+  on(event: string, cb: (...args: any[]) => void): void;
+  unref(): void;
+  ref(): void;
+};
+
+const sessions = new Map<string, Promise<Session | null>>();
+const http1Only = new Set<string>();
+const slots = new WeakMap<Session, { active: number; waiting: Array<() => void> }>();
+
+// A server caps the streams open at once on a connection (boat.dev: 250; this uses
+// at most 100). A stream past the cap is refused, so the excess waits here. Requests open
+// or waiting keep the process alive; an idle shared connection does not.
+async function streamSlot(s: Session, signal?: AbortSignal | null): Promise<() => void> {
+  let st = slots.get(s);
+  if (!st) { st = { active: 0, waiting: [] }; slots.set(s, st); }
+  const state = st;
+  const cap = Math.max(1, Math.min(Number((s as any).remoteSettings?.maxConcurrentStreams) || 100, 100));
+  // Already aborted: take no stream, never queue (an abort listener added now never fires).
+  if (signal?.aborted) return () => {};
+  if (state.active === 0 && state.waiting.length === 0) s.ref();
+  if (state.active >= cap) {
+    const turn = await new Promise<boolean>((wake) => {
+      const w = () => wake(true);
+      state.waiting.push(w);
+      // An aborted waiter leaves the queue without a stream; the caller rejects it.
+      signal?.addEventListener('abort', () => {
+        const i = state.waiting.indexOf(w);
+        if (i !== -1) { state.waiting.splice(i, 1); wake(false); }
+      }, { once: true });
+    });
+    if (!turn) return () => {};
+  }
+  state.active++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    state.active--;
+    const next = state.waiting.shift();
+    if (next) next();
+    else if (state.active === 0) s.unref();
+  };
+}
+let nodeHttp2: Promise<any | null> | undefined;
+
+function loadNode(): Promise<any | null> {
+  if (!nodeHttp2) {
+    const versions = (globalThis as any).process?.versions;
+    const isNode = !!versions?.node && !versions.bun && typeof (globalThis as any).Deno === 'undefined';
+    // A variable, not a literal: a browser bundler must not try to resolve it.
+    const h2 = 'node:http2';
+    nodeHttp2 = isNode
+      ? import(/* webpackIgnore: true */ /* @vite-ignore */ h2).catch(() => null)
+      : Promise.resolve(null);
+  }
+  return nodeHttp2;
+}
+
+function session(origin: string, http2: any): Promise<Session | null> {
+  const open = sessions.get(origin);
+  if (open) return open;
+  const pending = new Promise<Session | null>((resolve) => {
+    let s: any;
+    try {
+      s = http2.connect(origin);
+    } catch {
+      resolve(null);
+      return;
+    }
+    const drop = () => { if (sessions.get(origin) === pending) sessions.delete(origin); };
+    s.once('connect', () => {
+      // An origin that answered without h2 never gets here: the TLS layer fails the connect.
+      s.unref(); // an idle shared connection must not keep the process alive
+      resolve(s);
+    });
+    // `on`, not `once`: a session can emit more than one error, and an unhandled one kills the process.
+    s.on('error', () => { drop(); resolve(null); });
+    s.once('close', drop);
+    s.once('goaway', drop);
+  });
+  sessions.set(origin, pending);
+  return pending;
+}
+
+function sendableBody(body: unknown): string | Uint8Array | null | undefined {
+  if (body == null) return null;
+  if (typeof body === 'string') return body;
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof ArrayBuffer) return new Uint8Array(body);
+  if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) return body.toString();
+  return undefined; // FormData, Blob, streams: the global fetch encodes these
+}
+
+const HOP_BY_HOP = new Set(['connection', 'host', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'upgrade']);
+
+async function http2Fetch(input: RequestInfo | URL, init: RequestInit = {}): Promise<Response> {
+    const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
+    const body = sendableBody(init.body);
+    const node = await loadNode();
+    const isRequest = typeof input !== 'string' && !(input instanceof URL);
+    if (!node || isRequest || body === undefined || url.protocol !== 'https:' || http1Only.has(url.origin)) {
+      return fetch(input as any, init);
+    }
+    const s = await session(url.origin, node);
+    if (!s || s.closed || s.destroyed) {
+      if (!s) http1Only.add(url.origin);
+      return fetch(input as any, init);
+    }
+    const headers: Record<string, string> = { ':method': (init.method || 'GET').toUpperCase(), ':path': url.pathname + url.search };
+    new Headers(init.headers).forEach((value, key) => { if (!HOP_BY_HOP.has(key)) headers[key] = value; });
+    const signal = init.signal;
+    const aborted = () => signal!.reason ?? new DOMException('This operation was aborted', 'AbortError');
+    const release = await streamSlot(s, signal);
+    return new Promise<Response>((resolve, reject) => {
+      if (signal?.aborted) { release(); reject(aborted()); return; }
+      let req: any;
+      try {
+        req = s.request(headers, { endStream: body === null });
+      } catch (e) {
+        // The connection closed (GOAWAY) while this call waited for a stream.
+        release();
+        reject(e);
+        return;
+      }
+      const onAbort = () => { req.close(); reject(aborted()); };
+      signal?.addEventListener('abort', onAbort, { once: true });
+      req.once('close', () => { release(); signal?.removeEventListener('abort', onAbort); });
+      req.on('error', reject); // after the response this errors its body stream; a no-op here
+      req.once('response', (h: Record<string, string | string[]>) => {
+        const status = Number(h[':status']);
+        const out = new Headers();
+        for (const [k, v] of Object.entries(h)) {
+          if (k.startsWith(':') || v === undefined) continue;
+          for (const one of Array.isArray(v) ? v : [v]) out.append(k, String(one));
+        }
+        const empty = status === 204 || status === 205 || status === 304 || headers[':method'] === 'HEAD';
+        if (empty) req.resume();
+        // Fed from 'data' events, not Readable.toWeb: an HTTP/2 stream the server has
+        // already closed is destroyed with its unread data, and toWeb's backpressure
+        // turned that into "Premature close" on 25 of 250 calls (prod, 2026-10-08).
+        // A slow reader (streamCommand between frames) must not let a fast command
+        // fill memory: past 4 MiB unread the stream pauses until the reader pulls.
+        const bodyStream = empty ? null : new ReadableStream<Uint8Array>({
+          start(controller) {
+            req.on('data', (chunk: Uint8Array) => {
+              controller.enqueue(new Uint8Array(chunk));
+              if ((controller.desiredSize ?? 1) <= 0) req.pause();
+            });
+            req.once('end', () => controller.close());
+            req.once('error', (e: unknown) => controller.error(e));
+            req.once('close', () => {
+              if (!req.readableEnded) { try { controller.error(new Error(`HTTP/2 stream closed before its end (code ${req.rstCode})`)); } catch {} }
+            });
+          },
+          pull() { if (req.isPaused()) req.resume(); },
+          cancel() { req.close(); },
+        }, { highWaterMark: 4 * 1024 * 1024, size: (chunk) => chunk?.byteLength ?? 0 });
+        const response = new Response(bodyStream, { status, headers: out });
+        // Response.url is read-only; the generated client never reads it, but keep it right.
+        Object.defineProperty(response, 'url', { value: url.href });
+        resolve(response);
+      });
+      if (body !== null) req.end(body);
+    });
+}
+
+export const defaultFetch = http2Fetch as typeof fetch;

package/src/models/CreateSandboxRequest.ts

@@ -20,7 +20,7 @@ import { mapValues } from '../runtime';
  */
 export interface CreateSandboxRequest {
     /**
-     * Machine size. `small` consumes machine time at half rate and `large` at twice the default rate (see the Billing guide). A fork inherits the source sandbox's type unless the fork request passes its own, and resume and fork can move a sandbox between sizes.
+     * Machine size. `small` consumes machine time at half rate and `large` at twice the default rate (see the Billing guide). `xlarge` needs the $100/month plan or higher; lower plans get a 403 `machine_class_plan_required` on create, resume and fork. A fork inherits the source sandbox's type unless the fork request passes its own, and resume and fork can move a sandbox between sizes.
      * @type {CreateSandboxRequestTypeEnum}
      * @memberof CreateSandboxRequest
      */
@@ -62,7 +62,7 @@ export interface CreateSandboxRequest {
      */
     failFast?: boolean;
     /**
-     * Shell script that runs on the sandbox after it is ready. Ready means "ready to accept the user", not "setup done": the script starts in the background once provisioning completes and never blocks the sandbox becoming usable. It runs as the sandbox user via `bash`, with the sandbox's environment applied, and its output goes to a log file on the sandbox. Observe the outcome as `setupStatus` (pending/running/done/failed) and `setupError` on the sandbox. Rejected with a 400 `invalid_setup_script` error when it is not a string or exceeds 64KB.
+     * Shell script that runs on the sandbox after it is ready. Ready means "ready to accept the user", not "setup done": the script starts in the background once provisioning completes and never blocks the sandbox becoming usable. It runs as the sandbox user (`user`, not root; `sudo` needs no password) via `bash`, with the sandbox's environment applied, and its output goes to a log file on the sandbox. Observe the outcome as `setupStatus` (pending/running/done/failed) and `setupError` on the sandbox. Rejected with a 400 `invalid_setup_script` error when it is not a string or exceeds 64KB.
      * @type {string}
      * @memberof CreateSandboxRequest
      */
@@ -80,7 +80,7 @@ export interface CreateSandboxRequest {
      */
     teamId?: string;
     /**
-     * Create the sandbox from a named snapshot (saved with `POST /named-snapshots`, or `boat snapshot <id> <name>` in the CLI). The sandbox starts from that exact frozen state. Omitting `type` inherits the type the snapshot was saved from; env and no-env inherit from the snapshot's source sandbox unless the request passes its own, with the same rules as forking.
+     * Create the sandbox from a named snapshot (saved with `POST /named-snapshots`, or `boat snapshot <id> <name>` in the CLI). The sandbox starts from that exact frozen state. Omitting `type` inherits the type the snapshot was saved from; env and no-env inherit from the snapshot's source sandbox unless the request passes its own, with the same rules as forking. Also accepts a share code (`bsh_...`) that another account made with `POST /named-snapshots/{name}/shares`. The new sandbox lives in and is billed to your account. It does not get the owner's per-sandbox env; your own environment applies normally. A wrong or revoked code returns `404 snapshot_not_found`.
      * @type {string}
      * @memberof CreateSandboxRequest
      */
@@ -94,7 +94,8 @@ export interface CreateSandboxRequest {
 export const CreateSandboxRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type CreateSandboxRequestTypeEnum = typeof CreateSandboxRequestTypeEnum[keyof typeof CreateSandboxRequestTypeEnum];
 

package/src/models/ForkRequest.ts

@@ -44,7 +44,7 @@ export interface ForkRequest {
      */
     noEnv?: boolean;
     /**
-     * Machine size for the fork. Omit to inherit the source sandbox's type. The source sandbox is never modified. Shrinking is rejected with `type_too_small` when the source's data would not fit the smaller disk.
+     * Machine size for the fork. Omit to inherit the source sandbox's type. `xlarge` needs the $100/month plan or higher (403 `machine_class_plan_required`). The source sandbox is never modified. Shrinking is rejected with `type_too_small` when the source's data would not fit the smaller disk.
      * @type {ForkRequestTypeEnum}
      * @memberof ForkRequest
      */
@@ -64,7 +64,8 @@ export interface ForkRequest {
 export const ForkRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 } as const;
 export type ForkRequestTypeEnum = typeof ForkRequestTypeEnum[keyof typeof ForkRequestTypeEnum];
 

package/src/models/NamedSnapshotShare.ts

@@ -0,0 +1,131 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * A share code for a named snapshot. Any Boat account that holds the code can create a sandbox from the snapshot. Boat stores only a hash of the code. The full code is in the create response only.
+ * @export
+ * @interface NamedSnapshotShare
+ */
+export interface NamedSnapshotShare {
+    /**
+     * Share id, for example `shr_...`. Pass it to revoke the code.
+     * @type {string}
+     * @memberof NamedSnapshotShare
+     */
+    id: string;
+    /**
+     * The first characters of the code, for example `bsh_xxxxxxxx`. Use it to tell codes apart.
+     * @type {string}
+     * @memberof NamedSnapshotShare
+     */
+    codePrefix: string;
+    /**
+     * 
+     * @type {NamedSnapshotShareStatusEnum}
+     * @memberof NamedSnapshotShare
+     */
+    status: NamedSnapshotShareStatusEnum;
+    /**
+     * Number of sandboxes created with this code.
+     * @type {number}
+     * @memberof NamedSnapshotShare
+     */
+    useCount: number;
+    /**
+     * When a sandbox was last created with this code. null if never.
+     * @type {Date}
+     * @memberof NamedSnapshotShare
+     */
+    lastUsedAt: Date | null;
+    /**
+     * When the code was revoked. null while active.
+     * @type {Date}
+     * @memberof NamedSnapshotShare
+     */
+    revokedAt: Date | null;
+    /**
+     * 
+     * @type {Date}
+     * @memberof NamedSnapshotShare
+     */
+    createdAt: Date;
+}
+
+
+/**
+ * @export
+ */
+export const NamedSnapshotShareStatusEnum = {
+    Active: 'active',
+    Revoked: 'revoked'
+} as const;
+export type NamedSnapshotShareStatusEnum = typeof NamedSnapshotShareStatusEnum[keyof typeof NamedSnapshotShareStatusEnum];
+
+
+/**
+ * Check if a given object implements the NamedSnapshotShare interface.
+ */
+export function instanceOfNamedSnapshotShare(value: object): value is NamedSnapshotShare {
+    if (!('id' in value) || value['id'] === undefined) return false;
+    if (!('codePrefix' in value) || value['codePrefix'] === undefined) return false;
+    if (!('status' in value) || value['status'] === undefined) return false;
+    if (!('useCount' in value) || value['useCount'] === undefined) return false;
+    if (!('lastUsedAt' in value) || value['lastUsedAt'] === undefined) return false;
+    if (!('revokedAt' in value) || value['revokedAt'] === undefined) return false;
+    if (!('createdAt' in value) || value['createdAt'] === undefined) return false;
+    return true;
+}
+
+export function NamedSnapshotShareFromJSON(json: any): NamedSnapshotShare {
+    return NamedSnapshotShareFromJSONTyped(json, false);
+}
+
+export function NamedSnapshotShareFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamedSnapshotShare {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'id': json['id'],
+        'codePrefix': json['codePrefix'],
+        'status': json['status'],
+        'useCount': json['useCount'],
+        'lastUsedAt': (json['lastUsedAt'] == null ? null : new Date(json['lastUsedAt'])),
+        'revokedAt': (json['revokedAt'] == null ? null : new Date(json['revokedAt'])),
+        'createdAt': (new Date(json['createdAt'])),
+    };
+}
+
+export function NamedSnapshotShareToJSON(json: any): NamedSnapshotShare {
+    return NamedSnapshotShareToJSONTyped(json, false);
+}
+
+export function NamedSnapshotShareToJSONTyped(value?: NamedSnapshotShare | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'id': value['id'],
+        'codePrefix': value['codePrefix'],
+        'status': value['status'],
+        'useCount': value['useCount'],
+        'lastUsedAt': value['lastUsedAt'] == null ? value['lastUsedAt'] : value['lastUsedAt'].toISOString(),
+        'revokedAt': value['revokedAt'] == null ? value['revokedAt'] : value['revokedAt'].toISOString(),
+        'createdAt': value['createdAt'].toISOString(),
+    };
+}
+

package/src/models/NamedSnapshotShareCreatedResponse.ts

@@ -0,0 +1,120 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { NamedSnapshotShare } from './NamedSnapshotShare';
+import {
+    NamedSnapshotShareFromJSON,
+    NamedSnapshotShareFromJSONTyped,
+    NamedSnapshotShareToJSON,
+    NamedSnapshotShareToJSONTyped,
+} from './NamedSnapshotShare';
+
+/**
+ * 
+ * @export
+ * @interface NamedSnapshotShareCreatedResponse
+ */
+export interface NamedSnapshotShareCreatedResponse {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof NamedSnapshotShareCreatedResponse
+     */
+    ok: boolean;
+    /**
+     * 
+     * @type {NamedSnapshotShareCreatedResponseTypeEnum}
+     * @memberof NamedSnapshotShareCreatedResponse
+     */
+    type: NamedSnapshotShareCreatedResponseTypeEnum;
+    /**
+     * The named snapshot the code deploys.
+     * @type {string}
+     * @memberof NamedSnapshotShareCreatedResponse
+     */
+    name: string;
+    /**
+     * The share code, for example `bsh_...`. Boat shows it only in this response. Store it now; you cannot get it again.
+     * @type {string}
+     * @memberof NamedSnapshotShareCreatedResponse
+     */
+    shareCode: string;
+    /**
+     * 
+     * @type {NamedSnapshotShare}
+     * @memberof NamedSnapshotShareCreatedResponse
+     */
+    share: NamedSnapshotShare;
+}
+
+
+/**
+ * @export
+ */
+export const NamedSnapshotShareCreatedResponseTypeEnum = {
+    SnapshotShareCreated: 'snapshot.share.created'
+} as const;
+export type NamedSnapshotShareCreatedResponseTypeEnum = typeof NamedSnapshotShareCreatedResponseTypeEnum[keyof typeof NamedSnapshotShareCreatedResponseTypeEnum];
+
+
+/**
+ * Check if a given object implements the NamedSnapshotShareCreatedResponse interface.
+ */
+export function instanceOfNamedSnapshotShareCreatedResponse(value: object): value is NamedSnapshotShareCreatedResponse {
+    if (!('ok' in value) || value['ok'] === undefined) return false;
+    if (!('type' in value) || value['type'] === undefined) return false;
+    if (!('name' in value) || value['name'] === undefined) return false;
+    if (!('shareCode' in value) || value['shareCode'] === undefined) return false;
+    if (!('share' in value) || value['share'] === undefined) return false;
+    return true;
+}
+
+export function NamedSnapshotShareCreatedResponseFromJSON(json: any): NamedSnapshotShareCreatedResponse {
+    return NamedSnapshotShareCreatedResponseFromJSONTyped(json, false);
+}
+
+export function NamedSnapshotShareCreatedResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamedSnapshotShareCreatedResponse {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'ok': json['ok'],
+        'type': json['type'],
+        'name': json['name'],
+        'shareCode': json['shareCode'],
+        'share': NamedSnapshotShareFromJSON(json['share']),
+    };
+}
+
+export function NamedSnapshotShareCreatedResponseToJSON(json: any): NamedSnapshotShareCreatedResponse {
+    return NamedSnapshotShareCreatedResponseToJSONTyped(json, false);
+}
+
+export function NamedSnapshotShareCreatedResponseToJSONTyped(value?: NamedSnapshotShareCreatedResponse | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'ok': value['ok'],
+        'type': value['type'],
+        'name': value['name'],
+        'shareCode': value['shareCode'],
+        'share': NamedSnapshotShareToJSON(value['share']),
+    };
+}
+

package/src/models/NamedSnapshotShareListResponse.ts

@@ -0,0 +1,111 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1. 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { NamedSnapshotShare } from './NamedSnapshotShare';
+import {
+    NamedSnapshotShareFromJSON,
+    NamedSnapshotShareFromJSONTyped,
+    NamedSnapshotShareToJSON,
+    NamedSnapshotShareToJSONTyped,
+} from './NamedSnapshotShare';
+
+/**
+ * 
+ * @export
+ * @interface NamedSnapshotShareListResponse
+ */
+export interface NamedSnapshotShareListResponse {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof NamedSnapshotShareListResponse
+     */
+    ok: boolean;
+    /**
+     * 
+     * @type {NamedSnapshotShareListResponseTypeEnum}
+     * @memberof NamedSnapshotShareListResponse
+     */
+    type: NamedSnapshotShareListResponseTypeEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof NamedSnapshotShareListResponse
+     */
+    name: string;
+    /**
+     * 
+     * @type {Array<NamedSnapshotShare>}
+     * @memberof NamedSnapshotShareListResponse
+     */
+    shares: Array<NamedSnapshotShare>;
+}
+
+
+/**
+ * @export
+ */
+export const NamedSnapshotShareListResponseTypeEnum = {
+    SnapshotShareList: 'snapshot.share.list'
+} as const;
+export type NamedSnapshotShareListResponseTypeEnum = typeof NamedSnapshotShareListResponseTypeEnum[keyof typeof NamedSnapshotShareListResponseTypeEnum];
+
+
+/**
+ * Check if a given object implements the NamedSnapshotShareListResponse interface.
+ */
+export function instanceOfNamedSnapshotShareListResponse(value: object): value is NamedSnapshotShareListResponse {
+    if (!('ok' in value) || value['ok'] === undefined) return false;
+    if (!('type' in value) || value['type'] === undefined) return false;
+    if (!('name' in value) || value['name'] === undefined) return false;
+    if (!('shares' in value) || value['shares'] === undefined) return false;
+    return true;
+}
+
+export function NamedSnapshotShareListResponseFromJSON(json: any): NamedSnapshotShareListResponse {
+    return NamedSnapshotShareListResponseFromJSONTyped(json, false);
+}
+
+export function NamedSnapshotShareListResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamedSnapshotShareListResponse {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'ok': json['ok'],
+        'type': json['type'],
+        'name': json['name'],
+        'shares': ((json['shares'] as Array<any>).map(NamedSnapshotShareFromJSON)),
+    };
+}
+
+export function NamedSnapshotShareListResponseToJSON(json: any): NamedSnapshotShareListResponse {
+    return NamedSnapshotShareListResponseToJSONTyped(json, false);
+}
+
+export function NamedSnapshotShareListResponseToJSONTyped(value?: NamedSnapshotShareListResponse | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'ok': value['ok'],
+        'type': value['type'],
+        'name': value['name'],
+        'shares': ((value['shares'] as Array<any>).map(NamedSnapshotShareToJSON)),
+    };
+}
+