@ngrok/ngrok-api 0.13.0 → 0.16.0

package/src/datatypes.ts

@@ -1470,23 +1470,23 @@ export interface Endpoint {
   /** the local address the tunnel forwards to */
   upstreamUrl?: string;
   /** the protocol the agent uses to forward with */
-  upstreamProto?: string;
+  upstreamProtocol?: string;
   /** the url of the endpoint */
   url?: string;
   /** The ID of the owner (bot or user) that owns this endpoint */
   principal?: Ref;
-  /** TODO: deprecate me! */
-  principalId?: Ref;
   /** The traffic policy attached to this endpoint */
   trafficPolicy?: string;
   /** the bindings associated with this endpoint */
   bindings?: Array<string>;
   /** The tunnel session of the agent for this endpoint */
   tunnelSession?: Ref;
-  /** URI of the clep API resource */
+  /** URI of the Cloud Endpoint API resource */
   uri?: string;
   /** user supplied name for the endpoint */
   name?: string;
+  /** whether the endpoint allows pooling */
+  poolingEnabled: boolean;
 }
 
 export interface EndpointList {
@@ -1501,7 +1501,7 @@ export interface EndpointList {
 export interface EndpointCreate {
   /** the url of the endpoint */
   url: string;
-  /** whether the endpoint is `ephemeral` (served directly by an agent-initiated tunnel) or `edge` (served by an edge) or `cloud (represents a cloud endpoint)` */
+  /** Type of endpoint. Only 'cloud' is currently supported (represents a cloud endpoint). Defaults to 'cloud' if not specified. */
   type: string;
   /** The traffic policy attached to this endpoint */
   trafficPolicy: string;
@@ -1511,6 +1511,14 @@ export interface EndpointCreate {
   metadata?: string;
   /** the bindings associated with this endpoint */
   bindings?: Array<string>;
+  poolingEnabled: boolean;
+}
+
+export interface EndpointListArgs {
+  beforeId?: string;
+  limit?: string;
+  ids?: Array<string>;
+  urls?: Array<string>;
 }
 
 export interface EndpointUpdate {
@@ -1526,6 +1534,7 @@ export interface EndpointUpdate {
   metadata?: string;
   /** the bindings associated with this endpoint */
   bindings?: Array<string>;
+  poolingEnabled: boolean;
 }
 
 export interface EventDestinationCreate {
@@ -2025,6 +2034,63 @@ export interface ReservedDomainCertJob {
   retriesAt?: Date;
 }
 
+export interface SecretCreate {
+  /** Name of secret */
+  name: string;
+  /** Value of secret */
+  value: string;
+  /** Arbitrary user-defined metadata for this Secret */
+  metadata?: string;
+  /** description of Secret */
+  description?: string;
+  /** unique identifier of the referenced vault */
+  vaultId: string;
+}
+
+export interface SecretUpdate {
+  /** identifier for Secret */
+  id: string;
+  /** Name of secret */
+  name?: string;
+  /** Value of secret */
+  value?: string;
+  /** Arbitrary user-defined metadata for this Secret */
+  metadata?: string;
+  /** description of Secret */
+  description?: string;
+}
+
+export interface Secret {
+  /** identifier for Secret */
+  id: string;
+  /** URI of this Secret API resource */
+  uri: string;
+  /** Timestamp when the Secret was created (RFC 3339 format) */
+  createdAt: Date;
+  /** Timestamp when the Secret was last updated (RFC 3339 format) */
+  updatedAt: Date;
+  /** Name of secret */
+  name: string;
+  /** description of Secret */
+  description?: string;
+  /** Arbitrary user-defined metadata for this Secret */
+  metadata?: string;
+  /** Reference to who created this Secret */
+  createdBy: Ref;
+  /** Reference to who created this Secret */
+  lastUpdatedBy: Ref;
+  /** Reference to the vault the secret is stored in */
+  vault: Ref;
+}
+
+export interface SecretList {
+  /** The list of Secrets for this account */
+  secrets: Array<Secret>;
+  uri: string;
+  /** URI of the next page of results, or null if there is no next page */
+  nextPageUri?: string;
+}
+
 export interface SSHCertificateAuthorityCreate {
   /** human-readable description of this SSH Certificate Authority. optional, max 255 bytes. */
   description?: string;
@@ -2366,3 +2432,52 @@ export interface TunnelList {
   /** URI of the next page, or null if there is no next page */
   nextPageUri?: string;
 }
+
+export interface VaultCreate {
+  /** Name of vault */
+  name: string;
+  /** Arbitrary user-defined metadata for this Vault */
+  metadata: string;
+  /** description of Vault */
+  description: string;
+}
+
+export interface VaultUpdate {
+  /** identifier for Vault */
+  id: string;
+  /** Name of vault */
+  name?: string;
+  /** Arbitrary user-defined metadata for this Vault */
+  metadata?: string;
+  /** description of Vault */
+  description?: string;
+}
+
+export interface Vault {
+  /** identifier for Vault */
+  id: string;
+  /** URI of this Vault API resource */
+  uri: string;
+  /** Timestamp when the Vault was created (RFC 3339 format) */
+  createdAt: Date;
+  /** Timestamp when the Vault was last updated (RFC 3339 format) */
+  updatedAt: Date;
+  /** Name of vault */
+  name: string;
+  /** description of Vault */
+  description?: string;
+  /** Arbitrary user-defined metadata for this Vault */
+  metadata?: string;
+  /** Reference to who created this Vault */
+  createdBy: string;
+  /** Reference to who created this Vault */
+  lastUpdatedBy: string;
+}
+
+export interface VaultList {
+  /** The list of Vaults for this account */
+  vaults: Array<Vault>;
+  uri: string;
+  /** URI of the next page of results, or null if there is no next page */
+  nextPageUri?: string;
+}

package/src/services.ts

@@ -2485,7 +2485,9 @@ export class Endpoints {
     return array;
   }
 
-  private _pagedList(arg: datatypes.Paging): Promise<datatypes.EndpointList> {
+  private _pagedList(
+    arg: datatypes.EndpointListArgs
+  ): Promise<datatypes.EndpointList> {
     return this.httpClient
       .url(`/endpoints`)
       .query(arg)
@@ -2496,7 +2498,7 @@ export class Endpoints {
 
   private async *_asyncList(beforeId: string, limit = '100') {
     let nextPage = 'initial loop';
-    let page: datatypes.Paging = { limit: limit };
+    let page: datatypes.EndpointListArgs = { limit: limit };
 
     if (beforeId) {
       page.beforeId = beforeId;
@@ -3380,6 +3382,106 @@ export class ReservedDomains {
   }
 }
 
+/**
+ * Secrets is an api service for securely storing and managing sensitive data such as secrets, credentials, and tokens.
+ */
+export class Secrets {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>secrets</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a new Secret
+   */
+  public create(arg: datatypes.SecretCreate): Promise<datatypes.Secret> {
+    return this.httpClient
+      .url(`/vault_secrets`)
+      .post(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * Update an existing Secret by ID
+   */
+  public update(arg: datatypes.SecretUpdate): Promise<datatypes.Secret> {
+    return this.httpClient
+      .url(`/vault_secrets/${arg.id}`)
+      .patch(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * Delete a Secret
+   */
+  public delete(id): Promise<void> {
+    return this.httpClient
+      .url(`/vault_secrets/${id}`)
+      .delete()
+      .res()
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * Get a Secret by ID
+   */
+  public get(id): Promise<datatypes.Secret> {
+    return this.httpClient
+      .url(`/vault_secrets/${id}`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * List all Secrets owned by account
+   */
+  public async list(
+    beforeId?: string,
+    limit?: string
+  ): Promise<Array<datatypes.Secret>> {
+    const array: Array<datatypes.Secret> = [];
+    for await (const item of this._asyncList(beforeId, limit)) {
+      array.push(item);
+    }
+    return array;
+  }
+
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.SecretList> {
+    return this.httpClient
+      .url(`/vault_secrets`)
+      .query(arg)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(util.onFulfilled, util.onRejected);
+  }
+
+  private async *_asyncList(beforeId: string, limit = '100') {
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
+
+    if (beforeId) {
+      page.beforeId = beforeId;
+    }
+
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.Secret[] = pagedList.secrets;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+}
+
 /**
  * An SSH Certificate Authority is a pair of an SSH Certificate and its private
  key that can be used to sign other SSH host and user certificates.
@@ -3993,3 +4095,103 @@ export class Tunnels {
       .then(f => f, util.onRejected);
   }
 }
+
+/**
+ * Vaults is an api service for securely storing and managing sensitive data such as secrets, credentials, and tokens.
+ */
+export class Vaults {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>vaults</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a new Vault
+   */
+  public create(arg: datatypes.VaultCreate): Promise<datatypes.Vault> {
+    return this.httpClient
+      .url(`/vaults`)
+      .post(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * Update an existing Vault by ID
+   */
+  public update(arg: datatypes.VaultUpdate): Promise<datatypes.Vault> {
+    return this.httpClient
+      .url(`/vaults/${arg.id}`)
+      .patch(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * Delete a Vault
+   */
+  public delete(id): Promise<void> {
+    return this.httpClient
+      .url(`/vaults/${id}`)
+      .delete()
+      .res()
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * Get a Vault by ID
+   */
+  public get(id): Promise<datatypes.Vault> {
+    return this.httpClient
+      .url(`/vaults/${id}`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+  /**
+   * List all Vaults owned by account
+   */
+  public async list(
+    beforeId?: string,
+    limit?: string
+  ): Promise<Array<datatypes.Vault>> {
+    const array: Array<datatypes.Vault> = [];
+    for await (const item of this._asyncList(beforeId, limit)) {
+      array.push(item);
+    }
+    return array;
+  }
+
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.VaultList> {
+    return this.httpClient
+      .url(`/vaults`)
+      .query(arg)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(util.onFulfilled, util.onRejected);
+  }
+
+  private async *_asyncList(beforeId: string, limit = '100') {
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
+
+    if (beforeId) {
+      page.beforeId = beforeId;
+    }
+
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.Vault[] = pagedList.vaults;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+}