@opengeni/sdk 0.52.1 → 1.0.1

package/dist/{chunk-MZWTWOX6.js → chunk-ST5DDKJP.js}

@@ -9,14 +9,220 @@ var BROWSER_FRAME_MAX_DIMENSION = 32768;
 var BROWSER_FRAME_MAX_PIXELS = 1e8;
 var OpenGeniInteractionClient = class {
   attachedBrowsers;
+  authRuns;
   browsers;
   computers;
   identities;
+  interventions;
+  networkRoutes;
+  siteAuthConnections;
   constructor(transport) {
     this.attachedBrowsers = new AttachedBrowserDeviceCollection(transport);
+    this.authRuns = new AuthRunCollection(transport);
     this.browsers = new BrowserSessionCollection(transport);
     this.computers = new ComputerSessionCollection(transport);
     this.identities = new BrowserIdentityCollection(transport);
+    this.interventions = new InteractionInterventionCollection(transport);
+    this.networkRoutes = new NetworkRouteCollection(transport);
+    this.siteAuthConnections = new SiteAuthConnectionCollection(transport);
+  }
+};
+var NetworkRouteCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listNetworkRoutes(workspaceId, options);
+  }
+  route(workspaceId, networkRouteId) {
+    return new NetworkRouteResource(this.transport, workspaceId, networkRouteId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createNetworkRoute(workspaceId, request, options);
+    return this.route(workspaceId, response.route.id);
+  }
+};
+var NetworkRouteResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getNetworkRoute(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateNetworkRoute(this.workspaceId, this.id, request, options);
+  }
+};
+var SiteAuthConnectionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listSiteAuthConnections(workspaceId, options);
+  }
+  connection(workspaceId, connectionId) {
+    return new SiteAuthConnectionResource(this.transport, workspaceId, connectionId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createSiteAuthConnection(workspaceId, request, options);
+    return this.connection(workspaceId, response.connection.id);
+  }
+};
+var SiteAuthConnectionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getSiteAuthConnection(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateSiteAuthConnection(
+      this.workspaceId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var AuthRunCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listAuthRuns(workspaceId, options);
+  }
+  async get(workspaceId, authRunId, options = {}) {
+    return await this.transport.getAuthRun(workspaceId, authRunId, options);
+  }
+  run(workspaceId, browserSessionId, authRunId) {
+    return new AuthRunResource(this.transport, workspaceId, browserSessionId, authRunId);
+  }
+};
+var BrowserAuthRunCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listAuthRuns(this.workspaceId, {
+      ...options,
+      browserSessionId: this.browserSessionId
+    });
+  }
+  run(authRunId) {
+    return new AuthRunResource(this.transport, this.workspaceId, this.browserSessionId, authRunId);
+  }
+  async start(request, options = {}) {
+    const response = await this.transport.startBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      request,
+      options
+    );
+    return this.run(response.run.id);
+  }
+};
+var AuthRunResource = class {
+  constructor(transport, workspaceId, browserSessionId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    const run = await this.transport.getAuthRun(this.workspaceId, this.id, options);
+    if (run.browserSessionId !== this.browserSessionId) {
+      throw new Error("AuthRun belongs to another BrowserSession");
+    }
+    return run;
+  }
+  async report(request, options = {}) {
+    return await this.transport.reportBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async protectedFill(request, options = {}) {
+    return await this.transport.protectedBrowserAuthFill(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async advanceExternal(request, options = {}) {
+    return await this.transport.advanceExternalBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  /** Human-session helper. Hosted provider URLs never appear in model tools. */
+  async openExternalFlow(request, options = {}) {
+    return await this.transport.openExternalBrowserAuthFlow(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async verify(request, options = {}) {
+    return await this.transport.verifyBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var InteractionInterventionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listInteractionInterventions(workspaceId, options);
+  }
+  intervention(workspaceId, interventionId) {
+    return new InteractionInterventionResource(this.transport, workspaceId, interventionId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createInteractionIntervention(
+      workspaceId,
+      request,
+      options
+    );
+    return this.intervention(workspaceId, response.intervention.id);
+  }
+};
+var InteractionInterventionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getInteractionIntervention(this.workspaceId, this.id, options);
+  }
+  async resolve(request, options = {}) {
+    return await this.transport.resolveInteractionIntervention(
+      this.workspaceId,
+      this.id,
+      request,
+      options
+    );
   }
 };
 var AttachedBrowserDeviceCollection = class {
@@ -67,6 +273,9 @@ var BrowserIdentityResource = class {
   async revisions(options = {}) {
     return await this.transport.listBrowserRevisions(this.workspaceId, this.id, options);
   }
+  async update(request, options = {}) {
+    return await this.transport.updateBrowserIdentity(this.workspaceId, this.id, request, options);
+  }
 };
 var BrowserSessionCollection = class {
   constructor(transport) {
@@ -107,6 +316,7 @@ var BrowserSessionCollection = class {
         ...options.placement !== void 0 ? { placement: options.placement } : {},
         ...options.identityId !== void 0 ? { identityId: options.identityId } : {},
         ...options.baseRevisionId !== void 0 ? { baseRevisionId: options.baseRevisionId } : {},
+        ...options.networkRouteId !== void 0 ? { networkRouteId: options.networkRouteId } : {},
         ...options.linkedComputerSessionId !== void 0 ? { linkedComputerSessionId: options.linkedComputerSessionId } : {}
       },
       requestOptions
@@ -118,9 +328,15 @@ var BrowserSessionResource = class {
     this.transport = transport;
     this.workspaceId = workspaceId;
     this.id = id;
+    this.auth = new BrowserAuthRunCollection(transport, workspaceId, id);
+    this.clipboard = new BrowserClipboardResource(transport, workspaceId, id);
+    this.downloads = new BrowserDownloadCollection(transport, workspaceId, id);
     this.tabs = new BrowserTargetCollection(transport, workspaceId, id);
     this.targets = this.tabs;
   }
+  auth;
+  clipboard;
+  downloads;
   tabs;
   /** Alias for hosts that prefer the protocol term. */
   targets;
@@ -174,6 +390,83 @@ var BrowserSessionResource = class {
     return await this.transport.endBrowserSession(this.workspaceId, this.id, request, options);
   }
 };
+var BrowserClipboardResource = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async read(options = {}) {
+    const clipboard = await this.transport.readBrowserClipboard(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+    if (clipboard.browserSessionId !== this.browserSessionId) {
+      throw new Error("Browser clipboard belongs to another BrowserSession");
+    }
+    return clipboard;
+  }
+};
+var BrowserDownloadCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listBrowserDownloads(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+  }
+  download(downloadId) {
+    return new BrowserDownloadResource(
+      this.transport,
+      this.workspaceId,
+      this.browserSessionId,
+      downloadId
+    );
+  }
+};
+var BrowserDownloadResource = class {
+  constructor(transport, workspaceId, browserSessionId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    const download = await this.transport.getBrowserDownload(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      options
+    );
+    if (download.browserSessionId !== this.browserSessionId) {
+      throw new Error("BrowserDownload belongs to another BrowserSession");
+    }
+    return download;
+  }
+  /** Publish this exact private browser download into the source session's
+   * workspace. Pass an operationId when the caller needs retry identity across
+   * process boundaries; otherwise one is generated for this call. */
+  async saveToWorkspace(destinationPath, options = {}) {
+    const { operationId = crypto.randomUUID(), overwrite = false, ...requestOptions } = options;
+    const response = await this.transport.saveBrowserDownload(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      { operationId, destinationPath, overwrite },
+      requestOptions
+    );
+    if (response.download.id !== this.id || response.download.browserSessionId !== this.browserSessionId) {
+      throw new Error("BrowserDownload save returned another resource");
+    }
+    return response;
+  }
+};
 var BrowserTargetCollection = class {
   constructor(transport, workspaceId, browserSessionId) {
     this.transport = transport;
@@ -252,10 +545,12 @@ var ComputerSessionResource = class {
     this.id = id;
     this.targets = new ComputerTargetCollection(transport, workspaceId, id);
     this.apps = this.targets;
+    this.clipboard = new ComputerClipboardResource(transport, workspaceId, id);
   }
   targets;
   /** Native application/window targets are also the public app collection. */
   apps;
+  clipboard;
   async get(options = {}) {
     return await this.transport.getComputerSession(this.workspaceId, this.id, options);
   }
@@ -283,6 +578,24 @@ var ComputerSessionResource = class {
     return await this.transport.endComputerSession(this.workspaceId, this.id, request, options);
   }
 };
+var ComputerClipboardResource = class {
+  constructor(transport, workspaceId, computerSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.computerSessionId = computerSessionId;
+  }
+  async read(options = {}) {
+    const clipboard = await this.transport.readComputerClipboard(
+      this.workspaceId,
+      this.computerSessionId,
+      options
+    );
+    if (clipboard.computerSessionId !== this.computerSessionId) {
+      throw new Error("Computer clipboard belongs to another ComputerSession");
+    }
+    return clipboard;
+  }
+};
 var ComputerTargetCollection = class {
   constructor(transport, workspaceId, computerSessionId) {
     this.transport = transport;
@@ -641,15 +954,28 @@ export {
   BROWSER_FRAME_MAX_DIMENSION,
   BROWSER_FRAME_MAX_PIXELS,
   OpenGeniInteractionClient,
+  NetworkRouteCollection,
+  NetworkRouteResource,
+  SiteAuthConnectionCollection,
+  SiteAuthConnectionResource,
+  AuthRunCollection,
+  BrowserAuthRunCollection,
+  AuthRunResource,
+  InteractionInterventionCollection,
+  InteractionInterventionResource,
   AttachedBrowserDeviceCollection,
   AttachedBrowserDeviceResource,
   BrowserIdentityCollection,
   BrowserIdentityResource,
   BrowserSessionCollection,
   BrowserSessionResource,
+  BrowserClipboardResource,
+  BrowserDownloadCollection,
+  BrowserDownloadResource,
   BrowserTargetCollection,
   ComputerSessionCollection,
   ComputerSessionResource,
+  ComputerClipboardResource,
   ComputerTargetCollection,
   browserFrameSocketUrl,
   computerFrameSocketUrl,
@@ -658,4 +984,4 @@ export {
   parseBrowserFrameMetadata,
   parseComputerFrameMetadata
 };
-//# sourceMappingURL=chunk-MZWTWOX6.js.map
+//# sourceMappingURL=chunk-ST5DDKJP.js.map