@boatdev/sdk 1.0.1 → 1.2.0

package/src/models/CreateSandboxRequest.ts

@@ -49,6 +49,12 @@ export interface CreateSandboxRequest {
      * @memberof CreateSandboxRequest
      */
     noEnv?: boolean;
+    /**
+     * Pass `false` to never snapshot this sandbox. Nothing is captured in the background, so it pays no CPU or memory for it, and stopping it erases its disk the way zero data retention does. It cannot be resumed, forked, or saved as a named snapshot, and if its machine fails there is no backup to rebuild it from.
+     * @type {boolean}
+     * @memberof CreateSandboxRequest
+     */
+    snapshots?: 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.
      * @type {string}
@@ -109,6 +115,7 @@ export function CreateSandboxRequestFromJSONTyped(json: any, ignoreDiscriminator
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'noEnv': json['noEnv'] == null ? undefined : json['noEnv'],
+        'snapshots': json['snapshots'] == null ? undefined : json['snapshots'],
         'setupScript': json['setupScript'] == null ? undefined : json['setupScript'],
         'org': json['org'] == null ? undefined : json['org'],
         'teamId': json['teamId'] == null ? undefined : json['teamId'],
@@ -132,6 +139,7 @@ export function CreateSandboxRequestToJSONTyped(value?: CreateSandboxRequest | n
         'env': value['env'],
         'environment': value['environment'],
         'noEnv': value['noEnv'],
+        'snapshots': value['snapshots'],
         'setupScript': value['setupScript'],
         'org': value['org'],
         'teamId': value['teamId'],

package/src/models/DataRetentionPolicyResponse.ts

@@ -55,6 +55,18 @@ export interface DataRetentionPolicyResponse {
      * @memberof DataRetentionPolicyResponse
      */
     acceptedDeletionOperationsIrreversible?: boolean;
+    /**
+     * When true, every new sandbox of this account is created with snapshots off.
+     * @type {boolean}
+     * @memberof DataRetentionPolicyResponse
+     */
+    snapshotsOff?: boolean;
+    /**
+     * 
+     * @type {Date}
+     * @memberof DataRetentionPolicyResponse
+     */
+    snapshotsOffAt?: Date | null;
 }
 
 
@@ -95,6 +107,8 @@ export function DataRetentionPolicyResponseFromJSONTyped(json: any, ignoreDiscri
         'enabledAt': (json['enabledAt'] == null ? null : new Date(json['enabledAt'])),
         'queuedSandboxes': json['queuedSandboxes'] == null ? undefined : json['queuedSandboxes'],
         'acceptedDeletionOperationsIrreversible': json['acceptedDeletionOperationsIrreversible'] == null ? undefined : json['acceptedDeletionOperationsIrreversible'],
+        'snapshotsOff': json['snapshotsOff'] == null ? undefined : json['snapshotsOff'],
+        'snapshotsOffAt': json['snapshotsOffAt'] == null ? undefined : (new Date(json['snapshotsOffAt'])),
     };
 }
 
@@ -115,6 +129,8 @@ export function DataRetentionPolicyResponseToJSONTyped(value?: DataRetentionPoli
         'enabledAt': value['enabledAt'] == null ? value['enabledAt'] : value['enabledAt'].toISOString(),
         'queuedSandboxes': value['queuedSandboxes'],
         'acceptedDeletionOperationsIrreversible': value['acceptedDeletionOperationsIrreversible'],
+        'snapshotsOff': value['snapshotsOff'],
+        'snapshotsOffAt': value['snapshotsOffAt'] == null ? value['snapshotsOffAt'] : value['snapshotsOffAt'].toISOString(),
     };
 }
 

package/src/models/DataRetentionUpdateRequest.ts

@@ -14,7 +14,7 @@
 
 import { mapValues } from '../runtime';
 /**
- * 
+ * Pass `enabled` to change zero data retention, or `snapshotsOff` alone to change the account's snapshots-off setting.
  * @export
  * @interface DataRetentionUpdateRequest
  */
@@ -24,7 +24,13 @@ export interface DataRetentionUpdateRequest {
      * @type {boolean}
      * @memberof DataRetentionUpdateRequest
      */
-    enabled: boolean;
+    enabled?: boolean;
+    /**
+     * Turn snapshots off for every sandbox created from now on. Existing sandboxes keep their setting. While on, a create or fork that passes `snapshots: true` is refused with 409 `snapshots_off_for_account`.
+     * @type {boolean}
+     * @memberof DataRetentionUpdateRequest
+     */
+    snapshotsOff?: boolean;
     /**
      * Required when enabling and must exactly equal `delete archived sandbox data`.
      * @type {DataRetentionUpdateRequestConfirmationEnum}
@@ -47,7 +53,6 @@ export type DataRetentionUpdateRequestConfirmationEnum = typeof DataRetentionUpd
  * Check if a given object implements the DataRetentionUpdateRequest interface.
  */
 export function instanceOfDataRetentionUpdateRequest(value: object): value is DataRetentionUpdateRequest {
-    if (!('enabled' in value) || value['enabled'] === undefined) return false;
     return true;
 }
 
@@ -61,7 +66,8 @@ export function DataRetentionUpdateRequestFromJSONTyped(json: any, ignoreDiscrim
     }
     return {
         
-        'enabled': json['enabled'],
+        'enabled': json['enabled'] == null ? undefined : json['enabled'],
+        'snapshotsOff': json['snapshotsOff'] == null ? undefined : json['snapshotsOff'],
         'confirmation': json['confirmation'] == null ? undefined : json['confirmation'],
     };
 }
@@ -78,6 +84,7 @@ export function DataRetentionUpdateRequestToJSONTyped(value?: DataRetentionUpdat
     return {
         
         'enabled': value['enabled'],
+        'snapshotsOff': value['snapshotsOff'],
         'confirmation': value['confirmation'],
     };
 }

package/src/models/DeletionOperation.ts

@@ -49,6 +49,18 @@ export interface DeletionOperation {
      * @memberof DeletionOperation
      */
     status: DeletionOperationStatusEnum;
+    /**
+     * What the background purge is doing. The target is already gone from every list, restore and fork once the operation exists. `waiting_for_uploads`: stored data is erased once the last upload URL issued for it expires (`expectedBy`). `kept_for_newer_snapshots`: a newer snapshot you kept is built on this one; its data goes when they go. `waiting_for_restore`: a sandbox is still restoring from it. `retrying`: a transient fault, retried automatically.
+     * @type {DeletionOperationStageEnum}
+     * @memberof DeletionOperation
+     */
+    stage?: DeletionOperationStageEnum;
+    /**
+     * When `waiting_for_uploads` ends.
+     * @type {Date}
+     * @memberof DeletionOperation
+     */
+    expectedBy?: Date | null;
     /**
      * 
      * @type {number}
@@ -100,6 +112,19 @@ export const DeletionOperationStatusEnum = {
 } as const;
 export type DeletionOperationStatusEnum = typeof DeletionOperationStatusEnum[keyof typeof DeletionOperationStatusEnum];
 
+/**
+ * @export
+ */
+export const DeletionOperationStageEnum = {
+    Removing: 'removing',
+    WaitingForUploads: 'waiting_for_uploads',
+    KeptForNewerSnapshots: 'kept_for_newer_snapshots',
+    WaitingForRestore: 'waiting_for_restore',
+    Retrying: 'retrying',
+    Completed: 'completed'
+} as const;
+export type DeletionOperationStageEnum = typeof DeletionOperationStageEnum[keyof typeof DeletionOperationStageEnum];
+
 
 /**
  * Check if a given object implements the DeletionOperation interface.
@@ -131,6 +156,8 @@ export function DeletionOperationFromJSONTyped(json: any, ignoreDiscriminator: b
         'targetId': json['targetId'],
         'reason': json['reason'],
         'status': json['status'],
+        'stage': json['stage'] == null ? undefined : json['stage'],
+        'expectedBy': json['expectedBy'] == null ? undefined : (new Date(json['expectedBy'])),
         'attemptCount': json['attemptCount'],
         'requestedAt': (new Date(json['requestedAt'])),
         'completedAt': (json['completedAt'] == null ? null : new Date(json['completedAt'])),
@@ -153,6 +180,8 @@ export function DeletionOperationToJSONTyped(value?: DeletionOperation | null, i
         'targetId': value['targetId'],
         'reason': value['reason'],
         'status': value['status'],
+        'stage': value['stage'],
+        'expectedBy': value['expectedBy'] == null ? value['expectedBy'] : value['expectedBy'].toISOString(),
         'attemptCount': value['attemptCount'],
         'requestedAt': value['requestedAt'].toISOString(),
         'completedAt': value['completedAt'] == null ? value['completedAt'] : value['completedAt'].toISOString(),

package/src/models/DeletionOperationListResponse.ts

@@ -0,0 +1,102 @@
+/* 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 { DeletionOperation } from './DeletionOperation';
+import {
+    DeletionOperationFromJSON,
+    DeletionOperationFromJSONTyped,
+    DeletionOperationToJSON,
+    DeletionOperationToJSONTyped,
+} from './DeletionOperation';
+
+/**
+ * 
+ * @export
+ * @interface DeletionOperationListResponse
+ */
+export interface DeletionOperationListResponse {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof DeletionOperationListResponse
+     */
+    ok: boolean;
+    /**
+     * 
+     * @type {DeletionOperationListResponseTypeEnum}
+     * @memberof DeletionOperationListResponse
+     */
+    type: DeletionOperationListResponseTypeEnum;
+    /**
+     * 
+     * @type {Array<DeletionOperation>}
+     * @memberof DeletionOperationListResponse
+     */
+    operations: Array<DeletionOperation>;
+}
+
+
+/**
+ * @export
+ */
+export const DeletionOperationListResponseTypeEnum = {
+    SnapshotDeleting: 'snapshot.deleting'
+} as const;
+export type DeletionOperationListResponseTypeEnum = typeof DeletionOperationListResponseTypeEnum[keyof typeof DeletionOperationListResponseTypeEnum];
+
+
+/**
+ * Check if a given object implements the DeletionOperationListResponse interface.
+ */
+export function instanceOfDeletionOperationListResponse(value: object): value is DeletionOperationListResponse {
+    if (!('ok' in value) || value['ok'] === undefined) return false;
+    if (!('type' in value) || value['type'] === undefined) return false;
+    if (!('operations' in value) || value['operations'] === undefined) return false;
+    return true;
+}
+
+export function DeletionOperationListResponseFromJSON(json: any): DeletionOperationListResponse {
+    return DeletionOperationListResponseFromJSONTyped(json, false);
+}
+
+export function DeletionOperationListResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): DeletionOperationListResponse {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'ok': json['ok'],
+        'type': json['type'],
+        'operations': ((json['operations'] as Array<any>).map(DeletionOperationFromJSON)),
+    };
+}
+
+export function DeletionOperationListResponseToJSON(json: any): DeletionOperationListResponse {
+    return DeletionOperationListResponseToJSONTyped(json, false);
+}
+
+export function DeletionOperationListResponseToJSONTyped(value?: DeletionOperationListResponse | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'ok': value['ok'],
+        'type': value['type'],
+        'operations': ((value['operations'] as Array<any>).map(DeletionOperationToJSON)),
+    };
+}
+

package/src/models/Sandbox.ts

@@ -129,6 +129,12 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     desktopUrl?: string | null;
+    /**
+     * False when the sandbox was created with snapshots off.
+     * @type {boolean}
+     * @memberof Sandbox
+     */
+    snapshots?: boolean;
     /**
      * 
      * @type {boolean}
@@ -298,6 +304,7 @@ export function SandboxFromJSONTyped(json: any, ignoreDiscriminator: boolean): S
         'archiveAfter': json['archiveAfter'] == null ? undefined : (new Date(json['archiveAfter'])),
         'desktopAvailable': json['desktopAvailable'],
         'desktopUrl': json['desktopUrl'] == null ? undefined : json['desktopUrl'],
+        'snapshots': json['snapshots'] == null ? undefined : json['snapshots'],
         'snapshotAvailable': json['snapshotAvailable'],
         'snapshotCompletedAt': json['snapshotCompletedAt'] == null ? undefined : (new Date(json['snapshotCompletedAt'])),
         'snapshotVerifiedAt': json['snapshotVerifiedAt'] == null ? undefined : (new Date(json['snapshotVerifiedAt'])),
@@ -340,6 +347,7 @@ export function SandboxToJSONTyped(value?: Sandbox | null, ignoreDiscriminator:
         'archiveAfter': value['archiveAfter'] == null ? value['archiveAfter'] : value['archiveAfter'].toISOString(),
         'desktopAvailable': value['desktopAvailable'],
         'desktopUrl': value['desktopUrl'],
+        'snapshots': value['snapshots'],
         'snapshotAvailable': value['snapshotAvailable'],
         'snapshotCompletedAt': value['snapshotCompletedAt'] == null ? value['snapshotCompletedAt'] : value['snapshotCompletedAt'].toISOString(),
         'snapshotVerifiedAt': value['snapshotVerifiedAt'] == null ? value['snapshotVerifiedAt'] : value['snapshotVerifiedAt'].toISOString(),

package/src/models/index.ts

@@ -33,6 +33,7 @@ export * from './CreateScopedApiKeyRequest';
 export * from './DataRetentionPolicyResponse';
 export * from './DataRetentionUpdateRequest';
 export * from './DeletionOperation';
+export * from './DeletionOperationListResponse';
 export * from './DeletionOperationResponse';
 export * from './DesktopRequest';
 export * from './DesktopResponse';

package/src/runtime.ts

@@ -447,3 +447,26 @@ export class TextApiResponse {
         return await this.raw.text();
     };
 }
+
+
+/**
+ * A body-taking call's parameters with the body's fields inline, next to the
+ * path/query/header parameters: `fork({ sandboxId, type: 'small' })` is
+ * `fork({ sandboxId, forkRequest: { type: 'small' } })`. Both shapes are accepted.
+ */
+export type FlatBody<R, K extends keyof R> = Omit<R, K> & NonNullable<R[K]>;
+
+/** Turns either call shape into the wrapped one the generated code sends. */
+export function unflattenBody<R>(input: object, bodyKey: string, paramKeys: string[], sharedKeys: string[]): R {
+    if (input == null || bodyKey in input) return input as R;
+    const params: any = {};
+    const body: any = {};
+    for (const [k, v] of Object.entries(input)) {
+        const isParam = paramKeys.indexOf(k) !== -1;
+        if (isParam) params[k] = v;
+        if (!isParam || sharedKeys.indexOf(k) !== -1) body[k] = v;
+    }
+    // No body field given: send no body, exactly like the wrapped call with the key omitted.
+    if (Object.keys(body).length > 0) params[bodyKey] = body;
+    return params as R;
+}