Class v1.EdgeNetworkClient (0.4.0)

Package

Constructors

(constructor)(opts, gaxInstance)

constructor(opts?: ClientOptions, gaxInstance?: typeof gax | typeof gax.fallback);

Properties

apiEndpoint

get apiEndpoint(): string;

apiEndpoint

static get apiEndpoint(): string;

auth

auth: gax.GoogleAuth;

descriptors

descriptors: Descriptors;

edgeNetworkStub

edgeNetworkStub?: Promise<{
        [name: string]: Function;
    }>;

innerApiCalls

innerApiCalls: {
        [name: string]: Function;
    };

locationsClient

locationsClient: LocationsClient;

operationsClient

operationsClient: gax.OperationsClient;

pathTemplates

pathTemplates: {
        [name: string]: gax.PathTemplate;
    };

port

static get port(): number;

scopes

static get scopes(): string[];

servicePath

static get servicePath(): string;

universeDomain

get universeDomain(): string;

warn

warn: (code: string, message: string, warnType?: string) => void;

Methods

cancelOperation(request, options, callback)

cancelOperation(request: protos.google.longrunning.CancelOperationRequest, options?: gax.CallOptions | Callback<protos.google.protobuf.Empty, protos.google.longrunning.CancelOperationRequest, {} | undefined | null>, callback?: Callback<protos.google.longrunning.CancelOperationRequest, protos.google.protobuf.Empty, {} | undefined | null>): Promise<protos.google.protobuf.Empty>;

const client = longrunning.operationsClient();
await client.cancelOperation({name: ''});

checkCreateInterconnectAttachmentProgress(name)

checkCreateInterconnectAttachmentProgress(name: string): Promise<LROperation<protos.google.cloud.edgenetwork.v1.InterconnectAttachment, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  interconnect_attachment_id from the method_signature of Create RPC
   */
  // const interconnectAttachmentId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const interconnectAttachment = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateInterconnectAttachment() {
    // Construct request
    const request = {
      parent,
      interconnectAttachmentId,
      interconnectAttachment,
    };

    // Run request
    const [operation] = await edgenetworkClient.createInterconnectAttachment(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateInterconnectAttachment();

checkCreateNetworkProgress(name)

checkCreateNetworkProgress(name: string): Promise<LROperation<protos.google.cloud.edgenetwork.v1.Network, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  network_id from the method_signature of Create RPC
   */
  // const networkId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const network = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateNetwork() {
    // Construct request
    const request = {
      parent,
      networkId,
      network,
    };

    // Run request
    const [operation] = await edgenetworkClient.createNetwork(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateNetwork();

checkCreateRouterProgress(name)

checkCreateRouterProgress(name: string): Promise<LROperation<protos.google.cloud.edgenetwork.v1.Router, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  router_id from the method_signature of Create RPC
   */
  // const routerId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const router = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateRouter() {
    // Construct request
    const request = {
      parent,
      routerId,
      router,
    };

    // Run request
    const [operation] = await edgenetworkClient.createRouter(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateRouter();

checkCreateSubnetProgress(name)

checkCreateSubnetProgress(name: string): Promise<LROperation<protos.google.cloud.edgenetwork.v1.Subnet, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  subnet_id from the method_signature of Create RPC
   */
  // const subnetId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const subnet = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateSubnet() {
    // Construct request
    const request = {
      parent,
      subnetId,
      subnet,
    };

    // Run request
    const [operation] = await edgenetworkClient.createSubnet(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateSubnet();

checkDeleteInterconnectAttachmentProgress(name)

checkDeleteInterconnectAttachmentProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteInterconnectAttachment() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteInterconnectAttachment(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteInterconnectAttachment();

checkDeleteNetworkProgress(name)

checkDeleteNetworkProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteNetwork() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteNetwork(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteNetwork();

checkDeleteRouterProgress(name)

checkDeleteRouterProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteRouter() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteRouter(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteRouter();

checkDeleteSubnetProgress(name)

checkDeleteSubnetProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteSubnet() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteSubnet(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteSubnet();

checkUpdateRouterProgress(name)

checkUpdateRouterProgress(name: string): Promise<LROperation<protos.google.cloud.edgenetwork.v1.Router, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Field mask is used to specify the fields to be overwritten in the
   *  Router resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const router = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callUpdateRouter() {
    // Construct request
    const request = {
      updateMask,
      router,
    };

    // Run request
    const [operation] = await edgenetworkClient.updateRouter(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateRouter();

checkUpdateSubnetProgress(name)

checkUpdateSubnetProgress(name: string): Promise<LROperation<protos.google.cloud.edgenetwork.v1.Subnet, protos.google.cloud.edgenetwork.v1.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Field mask is used to specify the fields to be overwritten in the
   *  Subnet resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const subnet = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callUpdateSubnet() {
    // Construct request
    const request = {
      updateMask,
      subnet,
    };

    // Run request
    const [operation] = await edgenetworkClient.updateSubnet(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateSubnet();

close()

close(): Promise<void>;

createInterconnectAttachment(request, options)

createInterconnectAttachment(request?: protos.google.cloud.edgenetwork.v1.ICreateInterconnectAttachmentRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.edgenetwork.v1.IInterconnectAttachment, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  interconnect_attachment_id from the method_signature of Create RPC
   */
  // const interconnectAttachmentId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const interconnectAttachment = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateInterconnectAttachment() {
    // Construct request
    const request = {
      parent,
      interconnectAttachmentId,
      interconnectAttachment,
    };

    // Run request
    const [operation] = await edgenetworkClient.createInterconnectAttachment(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateInterconnectAttachment();

createInterconnectAttachment(request, options, callback)

createInterconnectAttachment(request: protos.google.cloud.edgenetwork.v1.ICreateInterconnectAttachmentRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.IInterconnectAttachment, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createInterconnectAttachment(request, callback)

createInterconnectAttachment(request: protos.google.cloud.edgenetwork.v1.ICreateInterconnectAttachmentRequest, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.IInterconnectAttachment, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createNetwork(request, options)

createNetwork(request?: protos.google.cloud.edgenetwork.v1.ICreateNetworkRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.edgenetwork.v1.INetwork, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  network_id from the method_signature of Create RPC
   */
  // const networkId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const network = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateNetwork() {
    // Construct request
    const request = {
      parent,
      networkId,
      network,
    };

    // Run request
    const [operation] = await edgenetworkClient.createNetwork(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateNetwork();

createNetwork(request, options, callback)

createNetwork(request: protos.google.cloud.edgenetwork.v1.ICreateNetworkRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.INetwork, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createNetwork(request, callback)

createNetwork(request: protos.google.cloud.edgenetwork.v1.ICreateNetworkRequest, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.INetwork, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createRouter(request, options)

createRouter(request?: protos.google.cloud.edgenetwork.v1.ICreateRouterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  router_id from the method_signature of Create RPC
   */
  // const routerId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const router = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateRouter() {
    // Construct request
    const request = {
      parent,
      routerId,
      router,
    };

    // Run request
    const [operation] = await edgenetworkClient.createRouter(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateRouter();

createRouter(request, options, callback)

createRouter(request: protos.google.cloud.edgenetwork.v1.ICreateRouterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createRouter(request, callback)

createRouter(request: protos.google.cloud.edgenetwork.v1.ICreateRouterRequest, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createSubnet(request, options)

createSubnet(request?: protos.google.cloud.edgenetwork.v1.ICreateSubnetRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. Id of the requesting object
   *  If auto-generating Id server-side, remove this field and
   *  subnet_id from the method_signature of Create RPC
   */
  // const subnetId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const subnet = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callCreateSubnet() {
    // Construct request
    const request = {
      parent,
      subnetId,
      subnet,
    };

    // Run request
    const [operation] = await edgenetworkClient.createSubnet(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateSubnet();

createSubnet(request, options, callback)

createSubnet(request: protos.google.cloud.edgenetwork.v1.ICreateSubnetRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createSubnet(request, callback)

createSubnet(request: protos.google.cloud.edgenetwork.v1.ICreateSubnetRequest, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteInterconnectAttachment(request, options)

deleteInterconnectAttachment(request?: protos.google.cloud.edgenetwork.v1.IDeleteInterconnectAttachmentRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteInterconnectAttachment() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteInterconnectAttachment(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteInterconnectAttachment();

deleteInterconnectAttachment(request, options, callback)

deleteInterconnectAttachment(request: protos.google.cloud.edgenetwork.v1.IDeleteInterconnectAttachmentRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteInterconnectAttachment(request, callback)

deleteInterconnectAttachment(request: protos.google.cloud.edgenetwork.v1.IDeleteInterconnectAttachmentRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteNetwork(request, options)

deleteNetwork(request?: protos.google.cloud.edgenetwork.v1.IDeleteNetworkRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteNetwork() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteNetwork(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteNetwork();

deleteNetwork(request, options, callback)

deleteNetwork(request: protos.google.cloud.edgenetwork.v1.IDeleteNetworkRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteNetwork(request, callback)

deleteNetwork(request: protos.google.cloud.edgenetwork.v1.IDeleteNetworkRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteOperation(request, options, callback)

deleteOperation(request: protos.google.longrunning.DeleteOperationRequest, options?: gax.CallOptions | Callback<protos.google.protobuf.Empty, protos.google.longrunning.DeleteOperationRequest, {} | null | undefined>, callback?: Callback<protos.google.protobuf.Empty, protos.google.longrunning.DeleteOperationRequest, {} | null | undefined>): Promise<protos.google.protobuf.Empty>;

const client = longrunning.operationsClient();
await client.deleteOperation({name: ''});

deleteRouter(request, options)

deleteRouter(request?: protos.google.cloud.edgenetwork.v1.IDeleteRouterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteRouter() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteRouter(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteRouter();

deleteRouter(request, options, callback)

deleteRouter(request: protos.google.cloud.edgenetwork.v1.IDeleteRouterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteRouter(request, callback)

deleteRouter(request: protos.google.cloud.edgenetwork.v1.IDeleteRouterRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteSubnet(request, options)

deleteSubnet(request?: protos.google.cloud.edgenetwork.v1.IDeleteSubnetRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDeleteSubnet() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await edgenetworkClient.deleteSubnet(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteSubnet();

deleteSubnet(request, options, callback)

deleteSubnet(request: protos.google.cloud.edgenetwork.v1.IDeleteSubnetRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteSubnet(request, callback)

deleteSubnet(request: protos.google.cloud.edgenetwork.v1.IDeleteSubnetRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

diagnoseInterconnect(request, options)

diagnoseInterconnect(request?: protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectResponse,
        (protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectRequest | undefined),
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the interconnect resource.
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDiagnoseInterconnect() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.diagnoseInterconnect(request);
    console.log(response);
  }

  callDiagnoseInterconnect();

diagnoseInterconnect(request, options, callback)

diagnoseInterconnect(request: protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectResponse, protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectRequest | null | undefined, {} | null | undefined>): void;

diagnoseInterconnect(request, callback)

diagnoseInterconnect(request: protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectResponse, protos.google.cloud.edgenetwork.v1.IDiagnoseInterconnectRequest | null | undefined, {} | null | undefined>): void;

diagnoseNetwork(request, options)

diagnoseNetwork(request?: protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkResponse,
        protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the network resource.
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDiagnoseNetwork() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.diagnoseNetwork(request);
    console.log(response);
  }

  callDiagnoseNetwork();

diagnoseNetwork(request, options, callback)

diagnoseNetwork(request: protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkResponse, protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkRequest | null | undefined, {} | null | undefined>): void;

diagnoseNetwork(request, callback)

diagnoseNetwork(request: protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkResponse, protos.google.cloud.edgenetwork.v1.IDiagnoseNetworkRequest | null | undefined, {} | null | undefined>): void;

diagnoseRouter(request, options)

diagnoseRouter(request?: protos.google.cloud.edgenetwork.v1.IDiagnoseRouterRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IDiagnoseRouterResponse,
        protos.google.cloud.edgenetwork.v1.IDiagnoseRouterRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the router resource.
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callDiagnoseRouter() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.diagnoseRouter(request);
    console.log(response);
  }

  callDiagnoseRouter();

diagnoseRouter(request, options, callback)

diagnoseRouter(request: protos.google.cloud.edgenetwork.v1.IDiagnoseRouterRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IDiagnoseRouterResponse, protos.google.cloud.edgenetwork.v1.IDiagnoseRouterRequest | null | undefined, {} | null | undefined>): void;

diagnoseRouter(request, callback)

diagnoseRouter(request: protos.google.cloud.edgenetwork.v1.IDiagnoseRouterRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IDiagnoseRouterResponse, protos.google.cloud.edgenetwork.v1.IDiagnoseRouterRequest | null | undefined, {} | null | undefined>): void;

getInterconnect(request, options)

getInterconnect(request?: protos.google.cloud.edgenetwork.v1.IGetInterconnectRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IInterconnect,
        protos.google.cloud.edgenetwork.v1.IGetInterconnectRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callGetInterconnect() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.getInterconnect(request);
    console.log(response);
  }

  callGetInterconnect();

getInterconnect(request, options, callback)

getInterconnect(request: protos.google.cloud.edgenetwork.v1.IGetInterconnectRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IInterconnect, protos.google.cloud.edgenetwork.v1.IGetInterconnectRequest | null | undefined, {} | null | undefined>): void;

getInterconnect(request, callback)

getInterconnect(request: protos.google.cloud.edgenetwork.v1.IGetInterconnectRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IInterconnect, protos.google.cloud.edgenetwork.v1.IGetInterconnectRequest | null | undefined, {} | null | undefined>): void;

getInterconnectAttachment(request, options)

getInterconnectAttachment(request?: protos.google.cloud.edgenetwork.v1.IGetInterconnectAttachmentRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IInterconnectAttachment,
        (protos.google.cloud.edgenetwork.v1.IGetInterconnectAttachmentRequest | undefined),
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callGetInterconnectAttachment() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.getInterconnectAttachment(request);
    console.log(response);
  }

  callGetInterconnectAttachment();

getInterconnectAttachment(request, options, callback)

getInterconnectAttachment(request: protos.google.cloud.edgenetwork.v1.IGetInterconnectAttachmentRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IInterconnectAttachment, protos.google.cloud.edgenetwork.v1.IGetInterconnectAttachmentRequest | null | undefined, {} | null | undefined>): void;

getInterconnectAttachment(request, callback)

getInterconnectAttachment(request: protos.google.cloud.edgenetwork.v1.IGetInterconnectAttachmentRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IInterconnectAttachment, protos.google.cloud.edgenetwork.v1.IGetInterconnectAttachmentRequest | null | undefined, {} | null | undefined>): void;

getLocation(request, options, callback)

getLocation(request: LocationProtos.google.cloud.location.IGetLocationRequest, options?: gax.CallOptions | Callback<LocationProtos.google.cloud.location.ILocation, LocationProtos.google.cloud.location.IGetLocationRequest | null | undefined, {} | null | undefined>, callback?: Callback<LocationProtos.google.cloud.location.ILocation, LocationProtos.google.cloud.location.IGetLocationRequest | null | undefined, {} | null | undefined>): Promise<LocationProtos.google.cloud.location.ILocation>;

const [response] = await client.getLocation(request);

getNetwork(request, options)

getNetwork(request?: protos.google.cloud.edgenetwork.v1.IGetNetworkRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.INetwork,
        protos.google.cloud.edgenetwork.v1.IGetNetworkRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callGetNetwork() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.getNetwork(request);
    console.log(response);
  }

  callGetNetwork();

getNetwork(request, options, callback)

getNetwork(request: protos.google.cloud.edgenetwork.v1.IGetNetworkRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.INetwork, protos.google.cloud.edgenetwork.v1.IGetNetworkRequest | null | undefined, {} | null | undefined>): void;

getNetwork(request, callback)

getNetwork(request: protos.google.cloud.edgenetwork.v1.IGetNetworkRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.INetwork, protos.google.cloud.edgenetwork.v1.IGetNetworkRequest | null | undefined, {} | null | undefined>): void;

getOperation(request, options, callback)

getOperation(request: protos.google.longrunning.GetOperationRequest, options?: gax.CallOptions | Callback<protos.google.longrunning.Operation, protos.google.longrunning.GetOperationRequest, {} | null | undefined>, callback?: Callback<protos.google.longrunning.Operation, protos.google.longrunning.GetOperationRequest, {} | null | undefined>): Promise<[protos.google.longrunning.Operation]>;

const client = longrunning.operationsClient();
const name = '';
const [response] = await client.getOperation({name});
// doThingsWith(response)

getProjectId()

getProjectId(): Promise<string>;

getProjectId(callback)

getProjectId(callback: Callback<string, undefined, undefined>): void;

getRouter(request, options)

getRouter(request?: protos.google.cloud.edgenetwork.v1.IGetRouterRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IRouter,
        protos.google.cloud.edgenetwork.v1.IGetRouterRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callGetRouter() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.getRouter(request);
    console.log(response);
  }

  callGetRouter();

getRouter(request, options, callback)

getRouter(request: protos.google.cloud.edgenetwork.v1.IGetRouterRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IGetRouterRequest | null | undefined, {} | null | undefined>): void;

getRouter(request, callback)

getRouter(request: protos.google.cloud.edgenetwork.v1.IGetRouterRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IGetRouterRequest | null | undefined, {} | null | undefined>): void;

getSubnet(request, options)

getSubnet(request?: protos.google.cloud.edgenetwork.v1.IGetSubnetRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.ISubnet,
        protos.google.cloud.edgenetwork.v1.IGetSubnetRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callGetSubnet() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.getSubnet(request);
    console.log(response);
  }

  callGetSubnet();

getSubnet(request, options, callback)

getSubnet(request: protos.google.cloud.edgenetwork.v1.IGetSubnetRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IGetSubnetRequest | null | undefined, {} | null | undefined>): void;

getSubnet(request, callback)

getSubnet(request: protos.google.cloud.edgenetwork.v1.IGetSubnetRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IGetSubnetRequest | null | undefined, {} | null | undefined>): void;

getZone(request, options)

getZone(request?: protos.google.cloud.edgenetwork.v1.IGetZoneRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IZone,
        protos.google.cloud.edgenetwork.v1.IGetZoneRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callGetZone() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.getZone(request);
    console.log(response);
  }

  callGetZone();

getZone(request, options, callback)

getZone(request: protos.google.cloud.edgenetwork.v1.IGetZoneRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IZone, protos.google.cloud.edgenetwork.v1.IGetZoneRequest | null | undefined, {} | null | undefined>): void;

getZone(request, callback)

getZone(request: protos.google.cloud.edgenetwork.v1.IGetZoneRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IZone, protos.google.cloud.edgenetwork.v1.IGetZoneRequest | null | undefined, {} | null | undefined>): void;

initialize()

initialize(): Promise<{
        [name: string]: Function;
    }>;

initializeZone(request, options)

initializeZone(request?: protos.google.cloud.edgenetwork.v1.IInitializeZoneRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IInitializeZoneResponse,
        protos.google.cloud.edgenetwork.v1.IInitializeZoneRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the zone resource.
   */
  // const name = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callInitializeZone() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await edgenetworkClient.initializeZone(request);
    console.log(response);
  }

  callInitializeZone();

initializeZone(request, options, callback)

initializeZone(request: protos.google.cloud.edgenetwork.v1.IInitializeZoneRequest, options: CallOptions, callback: Callback<protos.google.cloud.edgenetwork.v1.IInitializeZoneResponse, protos.google.cloud.edgenetwork.v1.IInitializeZoneRequest | null | undefined, {} | null | undefined>): void;

initializeZone(request, callback)

initializeZone(request: protos.google.cloud.edgenetwork.v1.IInitializeZoneRequest, callback: Callback<protos.google.cloud.edgenetwork.v1.IInitializeZoneResponse, protos.google.cloud.edgenetwork.v1.IInitializeZoneRequest | null | undefined, {} | null | undefined>): void;

interconnectAttachmentPath(project, location, zone, interconnectAttachment)

interconnectAttachmentPath(project: string, location: string, zone: string, interconnectAttachment: string): string;

interconnectPath(project, location, zone, interconnect)

interconnectPath(project: string, location: string, zone: string, interconnect: string): string;

listInterconnectAttachments(request, options)

listInterconnectAttachments(request?: protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IInterconnectAttachment[],
        protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest | null,
        protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsResponse
    ]>;

listInterconnectAttachments(request, options, callback)

listInterconnectAttachments(request: protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IInterconnectAttachment>): void;

listInterconnectAttachments(request, callback)

listInterconnectAttachments(request: protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IInterconnectAttachment>): void;

listInterconnectAttachmentsAsync(request, options)

listInterconnectAttachmentsAsync(request?: protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.edgenetwork.v1.IInterconnectAttachment>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListInterconnectAttachmentsRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callListInterconnectAttachments() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = edgenetworkClient.listInterconnectAttachmentsAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListInterconnectAttachments();

listInterconnectAttachmentsStream(request, options)

listInterconnectAttachmentsStream(request?: protos.google.cloud.edgenetwork.v1.IListInterconnectAttachmentsRequest, options?: CallOptions): Transform;

listInterconnects(request, options)

listInterconnects(request?: protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IInterconnect[],
        protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest | null,
        protos.google.cloud.edgenetwork.v1.IListInterconnectsResponse
    ]>;

listInterconnects(request, options, callback)

listInterconnects(request: protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, protos.google.cloud.edgenetwork.v1.IListInterconnectsResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IInterconnect>): void;

listInterconnects(request, callback)

listInterconnects(request: protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, protos.google.cloud.edgenetwork.v1.IListInterconnectsResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IInterconnect>): void;

listInterconnectsAsync(request, options)

listInterconnectsAsync(request?: protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.edgenetwork.v1.IInterconnect>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListInterconnectsRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callListInterconnects() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = edgenetworkClient.listInterconnectsAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListInterconnects();

listInterconnectsStream(request, options)

listInterconnectsStream(request?: protos.google.cloud.edgenetwork.v1.IListInterconnectsRequest, options?: CallOptions): Transform;

listLocationsAsync(request, options)

listLocationsAsync(request: LocationProtos.google.cloud.location.IListLocationsRequest, options?: CallOptions): AsyncIterable<LocationProtos.google.cloud.location.ILocation>;

const iterable = client.listLocationsAsync(request);
for await (const response of iterable) {
  // process response
}

listNetworks(request, options)

listNetworks(request?: protos.google.cloud.edgenetwork.v1.IListNetworksRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.INetwork[],
        protos.google.cloud.edgenetwork.v1.IListNetworksRequest | null,
        protos.google.cloud.edgenetwork.v1.IListNetworksResponse
    ]>;

listNetworks(request, options, callback)

listNetworks(request: protos.google.cloud.edgenetwork.v1.IListNetworksRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListNetworksRequest, protos.google.cloud.edgenetwork.v1.IListNetworksResponse | null | undefined, protos.google.cloud.edgenetwork.v1.INetwork>): void;

listNetworks(request, callback)

listNetworks(request: protos.google.cloud.edgenetwork.v1.IListNetworksRequest, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListNetworksRequest, protos.google.cloud.edgenetwork.v1.IListNetworksResponse | null | undefined, protos.google.cloud.edgenetwork.v1.INetwork>): void;

listNetworksAsync(request, options)

listNetworksAsync(request?: protos.google.cloud.edgenetwork.v1.IListNetworksRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.edgenetwork.v1.INetwork>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListNetworksRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callListNetworks() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = edgenetworkClient.listNetworksAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListNetworks();

listNetworksStream(request, options)

listNetworksStream(request?: protos.google.cloud.edgenetwork.v1.IListNetworksRequest, options?: CallOptions): Transform;

listOperationsAsync(request, options)

listOperationsAsync(request: protos.google.longrunning.ListOperationsRequest, options?: gax.CallOptions): AsyncIterable<protos.google.longrunning.ListOperationsResponse>;

const client = longrunning.operationsClient();
for await (const response of client.listOperationsAsync(request));
// doThingsWith(response)

listRouters(request, options)

listRouters(request?: protos.google.cloud.edgenetwork.v1.IListRoutersRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IRouter[],
        protos.google.cloud.edgenetwork.v1.IListRoutersRequest | null,
        protos.google.cloud.edgenetwork.v1.IListRoutersResponse
    ]>;

listRouters(request, options, callback)

listRouters(request: protos.google.cloud.edgenetwork.v1.IListRoutersRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListRoutersRequest, protos.google.cloud.edgenetwork.v1.IListRoutersResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IRouter>): void;

listRouters(request, callback)

listRouters(request: protos.google.cloud.edgenetwork.v1.IListRoutersRequest, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListRoutersRequest, protos.google.cloud.edgenetwork.v1.IListRoutersResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IRouter>): void;

listRoutersAsync(request, options)

listRoutersAsync(request?: protos.google.cloud.edgenetwork.v1.IListRoutersRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.edgenetwork.v1.IRouter>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListRoutersRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callListRouters() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = edgenetworkClient.listRoutersAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListRouters();

listRoutersStream(request, options)

listRoutersStream(request?: protos.google.cloud.edgenetwork.v1.IListRoutersRequest, options?: CallOptions): Transform;

listSubnets(request, options)

listSubnets(request?: protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.ISubnet[],
        protos.google.cloud.edgenetwork.v1.IListSubnetsRequest | null,
        protos.google.cloud.edgenetwork.v1.IListSubnetsResponse
    ]>;

listSubnets(request, options, callback)

listSubnets(request: protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, protos.google.cloud.edgenetwork.v1.IListSubnetsResponse | null | undefined, protos.google.cloud.edgenetwork.v1.ISubnet>): void;

listSubnets(request, callback)

listSubnets(request: protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, protos.google.cloud.edgenetwork.v1.IListSubnetsResponse | null | undefined, protos.google.cloud.edgenetwork.v1.ISubnet>): void;

listSubnetsAsync(request, options)

listSubnetsAsync(request?: protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.edgenetwork.v1.ISubnet>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListSubnetsRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callListSubnets() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = edgenetworkClient.listSubnetsAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListSubnets();

listSubnetsStream(request, options)

listSubnetsStream(request?: protos.google.cloud.edgenetwork.v1.IListSubnetsRequest, options?: CallOptions): Transform;

listZones(request, options)

listZones(request?: protos.google.cloud.edgenetwork.v1.IListZonesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.edgenetwork.v1.IZone[],
        protos.google.cloud.edgenetwork.v1.IListZonesRequest | null,
        protos.google.cloud.edgenetwork.v1.IListZonesResponse
    ]>;

listZones(request, options, callback)

listZones(request: protos.google.cloud.edgenetwork.v1.IListZonesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListZonesRequest, protos.google.cloud.edgenetwork.v1.IListZonesResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IZone>): void;

listZones(request, callback)

listZones(request: protos.google.cloud.edgenetwork.v1.IListZonesRequest, callback: PaginationCallback<protos.google.cloud.edgenetwork.v1.IListZonesRequest, protos.google.cloud.edgenetwork.v1.IListZonesResponse | null | undefined, protos.google.cloud.edgenetwork.v1.IZone>): void;

listZonesAsync(request, options)

listZonesAsync(request?: protos.google.cloud.edgenetwork.v1.IListZonesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.edgenetwork.v1.IZone>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListZonesRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callListZones() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = edgenetworkClient.listZonesAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListZones();

listZonesStream(request, options)

listZonesStream(request?: protos.google.cloud.edgenetwork.v1.IListZonesRequest, options?: CallOptions): Transform;

locationPath(project, location)

locationPath(project: string, location: string): string;

matchInterconnectAttachmentFromInterconnectAttachmentName(interconnectAttachmentName)

matchInterconnectAttachmentFromInterconnectAttachmentName(interconnectAttachmentName: string): string | number;

matchInterconnectFromInterconnectName(interconnectName)

matchInterconnectFromInterconnectName(interconnectName: string): string | number;

matchLocationFromInterconnectAttachmentName(interconnectAttachmentName)

matchLocationFromInterconnectAttachmentName(interconnectAttachmentName: string): string | number;

matchLocationFromInterconnectName(interconnectName)

matchLocationFromInterconnectName(interconnectName: string): string | number;

matchLocationFromLocationName(locationName)

matchLocationFromLocationName(locationName: string): string | number;

matchLocationFromNetworkName(networkName)

matchLocationFromNetworkName(networkName: string): string | number;

matchLocationFromRouterName(routerName)

matchLocationFromRouterName(routerName: string): string | number;

matchLocationFromSubnetName(subnetName)

matchLocationFromSubnetName(subnetName: string): string | number;

matchLocationFromZoneName(zoneName)

matchLocationFromZoneName(zoneName: string): string | number;

matchNetworkFromNetworkName(networkName)

matchNetworkFromNetworkName(networkName: string): string | number;

matchProjectFromInterconnectAttachmentName(interconnectAttachmentName)

matchProjectFromInterconnectAttachmentName(interconnectAttachmentName: string): string | number;

matchProjectFromInterconnectName(interconnectName)

matchProjectFromInterconnectName(interconnectName: string): string | number;

matchProjectFromLocationName(locationName)

matchProjectFromLocationName(locationName: string): string | number;

matchProjectFromNetworkName(networkName)

matchProjectFromNetworkName(networkName: string): string | number;

matchProjectFromProjectName(projectName)

matchProjectFromProjectName(projectName: string): string | number;

matchProjectFromRouterName(routerName)

matchProjectFromRouterName(routerName: string): string | number;

matchProjectFromSubnetName(subnetName)

matchProjectFromSubnetName(subnetName: string): string | number;

matchProjectFromZoneName(zoneName)

matchProjectFromZoneName(zoneName: string): string | number;

matchRouterFromRouterName(routerName)

matchRouterFromRouterName(routerName: string): string | number;

matchSubnetFromSubnetName(subnetName)

matchSubnetFromSubnetName(subnetName: string): string | number;

matchZoneFromInterconnectAttachmentName(interconnectAttachmentName)

matchZoneFromInterconnectAttachmentName(interconnectAttachmentName: string): string | number;

matchZoneFromInterconnectName(interconnectName)

matchZoneFromInterconnectName(interconnectName: string): string | number;

matchZoneFromNetworkName(networkName)

matchZoneFromNetworkName(networkName: string): string | number;

matchZoneFromRouterName(routerName)

matchZoneFromRouterName(routerName: string): string | number;

matchZoneFromSubnetName(subnetName)

matchZoneFromSubnetName(subnetName: string): string | number;

matchZoneFromZoneName(zoneName)

matchZoneFromZoneName(zoneName: string): string | number;

networkPath(project, location, zone, network)

networkPath(project: string, location: string, zone: string, network: string): string;

projectPath(project)

projectPath(project: string): string;

routerPath(project, location, zone, router)

routerPath(project: string, location: string, zone: string, router: string): string;

subnetPath(project, location, zone, subnet)

subnetPath(project: string, location: string, zone: string, subnet: string): string;

updateRouter(request, options)

updateRouter(request?: protos.google.cloud.edgenetwork.v1.IUpdateRouterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Field mask is used to specify the fields to be overwritten in the
   *  Router resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const router = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callUpdateRouter() {
    // Construct request
    const request = {
      updateMask,
      router,
    };

    // Run request
    const [operation] = await edgenetworkClient.updateRouter(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateRouter();

updateRouter(request, options, callback)

updateRouter(request: protos.google.cloud.edgenetwork.v1.IUpdateRouterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateRouter(request, callback)

updateRouter(request: protos.google.cloud.edgenetwork.v1.IUpdateRouterRequest, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.IRouter, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateSubnet(request, options)

updateSubnet(request?: protos.google.cloud.edgenetwork.v1.IUpdateSubnetRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Field mask is used to specify the fields to be overwritten in the
   *  Subnet resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const subnet = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Edgenetwork library
  const {EdgeNetworkClient} = require('@google-cloud/edgenetwork').v1;

  // Instantiates a client
  const edgenetworkClient = new EdgeNetworkClient();

  async function callUpdateSubnet() {
    // Construct request
    const request = {
      updateMask,
      subnet,
    };

    // Run request
    const [operation] = await edgenetworkClient.updateSubnet(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateSubnet();

updateSubnet(request, options, callback)

updateSubnet(request: protos.google.cloud.edgenetwork.v1.IUpdateSubnetRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateSubnet(request, callback)

updateSubnet(request: protos.google.cloud.edgenetwork.v1.IUpdateSubnetRequest, callback: Callback<LROperation<protos.google.cloud.edgenetwork.v1.ISubnet, protos.google.cloud.edgenetwork.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

zonePath(project, location, zone)

zonePath(project: string, location: string, zone: string): string;