@highstate/designer 0.3.2 → 0.3.3

package/.output/server/node_modules/@grpc/grpc-js/build/src/experimental.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCertificateProviderChannelCredentials = exports.FileWatcherCertificateProvider = exports.createCertificateProviderServerCredentials = exports.createServerCredentialsWithInterceptors = exports.BaseSubchannelWrapper = exports.registerAdminService = exports.FilterStackFactory = exports.BaseFilter = exports.PickResultType = exports.QueuePicker = exports.UnavailablePicker = exports.ChildLoadBalancerHandler = exports.EndpointMap = exports.endpointHasAddress = exports.endpointToString = exports.subchannelAddressToString = exports.LeafLoadBalancer = exports.isLoadBalancerNameRegistered = exports.parseLoadBalancingConfig = exports.selectLbConfigFromList = exports.registerLoadBalancerType = exports.createChildChannelControlHelper = exports.BackoffTimeout = exports.parseDuration = exports.durationToMs = exports.splitHostPort = exports.uriToString = exports.createResolver = exports.registerResolver = exports.log = exports.trace = void 0;
+var logging_1 = require("./logging");
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return logging_1.trace; } });
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return logging_1.log; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "registerResolver", { enumerable: true, get: function () { return resolver_1.registerResolver; } });
+Object.defineProperty(exports, "createResolver", { enumerable: true, get: function () { return resolver_1.createResolver; } });
+var uri_parser_1 = require("./uri-parser");
+Object.defineProperty(exports, "uriToString", { enumerable: true, get: function () { return uri_parser_1.uriToString; } });
+Object.defineProperty(exports, "splitHostPort", { enumerable: true, get: function () { return uri_parser_1.splitHostPort; } });
+var duration_1 = require("./duration");
+Object.defineProperty(exports, "durationToMs", { enumerable: true, get: function () { return duration_1.durationToMs; } });
+Object.defineProperty(exports, "parseDuration", { enumerable: true, get: function () { return duration_1.parseDuration; } });
+var backoff_timeout_1 = require("./backoff-timeout");
+Object.defineProperty(exports, "BackoffTimeout", { enumerable: true, get: function () { return backoff_timeout_1.BackoffTimeout; } });
+var load_balancer_1 = require("./load-balancer");
+Object.defineProperty(exports, "createChildChannelControlHelper", { enumerable: true, get: function () { return load_balancer_1.createChildChannelControlHelper; } });
+Object.defineProperty(exports, "registerLoadBalancerType", { enumerable: true, get: function () { return load_balancer_1.registerLoadBalancerType; } });
+Object.defineProperty(exports, "selectLbConfigFromList", { enumerable: true, get: function () { return load_balancer_1.selectLbConfigFromList; } });
+Object.defineProperty(exports, "parseLoadBalancingConfig", { enumerable: true, get: function () { return load_balancer_1.parseLoadBalancingConfig; } });
+Object.defineProperty(exports, "isLoadBalancerNameRegistered", { enumerable: true, get: function () { return load_balancer_1.isLoadBalancerNameRegistered; } });
+var load_balancer_pick_first_1 = require("./load-balancer-pick-first");
+Object.defineProperty(exports, "LeafLoadBalancer", { enumerable: true, get: function () { return load_balancer_pick_first_1.LeafLoadBalancer; } });
+var subchannel_address_1 = require("./subchannel-address");
+Object.defineProperty(exports, "subchannelAddressToString", { enumerable: true, get: function () { return subchannel_address_1.subchannelAddressToString; } });
+Object.defineProperty(exports, "endpointToString", { enumerable: true, get: function () { return subchannel_address_1.endpointToString; } });
+Object.defineProperty(exports, "endpointHasAddress", { enumerable: true, get: function () { return subchannel_address_1.endpointHasAddress; } });
+Object.defineProperty(exports, "EndpointMap", { enumerable: true, get: function () { return subchannel_address_1.EndpointMap; } });
+var load_balancer_child_handler_1 = require("./load-balancer-child-handler");
+Object.defineProperty(exports, "ChildLoadBalancerHandler", { enumerable: true, get: function () { return load_balancer_child_handler_1.ChildLoadBalancerHandler; } });
+var picker_1 = require("./picker");
+Object.defineProperty(exports, "UnavailablePicker", { enumerable: true, get: function () { return picker_1.UnavailablePicker; } });
+Object.defineProperty(exports, "QueuePicker", { enumerable: true, get: function () { return picker_1.QueuePicker; } });
+Object.defineProperty(exports, "PickResultType", { enumerable: true, get: function () { return picker_1.PickResultType; } });
+var filter_1 = require("./filter");
+Object.defineProperty(exports, "BaseFilter", { enumerable: true, get: function () { return filter_1.BaseFilter; } });
+var filter_stack_1 = require("./filter-stack");
+Object.defineProperty(exports, "FilterStackFactory", { enumerable: true, get: function () { return filter_stack_1.FilterStackFactory; } });
+var admin_1 = require("./admin");
+Object.defineProperty(exports, "registerAdminService", { enumerable: true, get: function () { return admin_1.registerAdminService; } });
+var subchannel_interface_1 = require("./subchannel-interface");
+Object.defineProperty(exports, "BaseSubchannelWrapper", { enumerable: true, get: function () { return subchannel_interface_1.BaseSubchannelWrapper; } });
+var server_credentials_1 = require("./server-credentials");
+Object.defineProperty(exports, "createServerCredentialsWithInterceptors", { enumerable: true, get: function () { return server_credentials_1.createServerCredentialsWithInterceptors; } });
+Object.defineProperty(exports, "createCertificateProviderServerCredentials", { enumerable: true, get: function () { return server_credentials_1.createCertificateProviderServerCredentials; } });
+var certificate_provider_1 = require("./certificate-provider");
+Object.defineProperty(exports, "FileWatcherCertificateProvider", { enumerable: true, get: function () { return certificate_provider_1.FileWatcherCertificateProvider; } });
+var channel_credentials_1 = require("./channel-credentials");
+Object.defineProperty(exports, "createCertificateProviderChannelCredentials", { enumerable: true, get: function () { return channel_credentials_1.createCertificateProviderChannelCredentials; } });
+//# sourceMappingURL=experimental.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/filter-stack.js

@@ -0,0 +1,82 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterStackFactory = exports.FilterStack = void 0;
+class FilterStack {
+    constructor(filters) {
+        this.filters = filters;
+    }
+    sendMetadata(metadata) {
+        let result = metadata;
+        for (let i = 0; i < this.filters.length; i++) {
+            result = this.filters[i].sendMetadata(result);
+        }
+        return result;
+    }
+    receiveMetadata(metadata) {
+        let result = metadata;
+        for (let i = this.filters.length - 1; i >= 0; i--) {
+            result = this.filters[i].receiveMetadata(result);
+        }
+        return result;
+    }
+    sendMessage(message) {
+        let result = message;
+        for (let i = 0; i < this.filters.length; i++) {
+            result = this.filters[i].sendMessage(result);
+        }
+        return result;
+    }
+    receiveMessage(message) {
+        let result = message;
+        for (let i = this.filters.length - 1; i >= 0; i--) {
+            result = this.filters[i].receiveMessage(result);
+        }
+        return result;
+    }
+    receiveTrailers(status) {
+        let result = status;
+        for (let i = this.filters.length - 1; i >= 0; i--) {
+            result = this.filters[i].receiveTrailers(result);
+        }
+        return result;
+    }
+    push(filters) {
+        this.filters.unshift(...filters);
+    }
+    getFilters() {
+        return this.filters;
+    }
+}
+exports.FilterStack = FilterStack;
+class FilterStackFactory {
+    constructor(factories) {
+        this.factories = factories;
+    }
+    push(filterFactories) {
+        this.factories.unshift(...filterFactories);
+    }
+    clone() {
+        return new FilterStackFactory([...this.factories]);
+    }
+    createFilter() {
+        return new FilterStack(this.factories.map(factory => factory.createFilter()));
+    }
+}
+exports.FilterStackFactory = FilterStackFactory;
+//# sourceMappingURL=filter-stack.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/filter.js

@@ -0,0 +1,38 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFilter = void 0;
+class BaseFilter {
+    async sendMetadata(metadata) {
+        return metadata;
+    }
+    receiveMetadata(metadata) {
+        return metadata;
+    }
+    async sendMessage(message) {
+        return message;
+    }
+    async receiveMessage(message) {
+        return message;
+    }
+    receiveTrailers(status) {
+        return status;
+    }
+}
+exports.BaseFilter = BaseFilter;
+//# sourceMappingURL=filter.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/http_proxy.js

@@ -0,0 +1,266 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProxiedConnection = exports.mapProxyName = void 0;
+const logging_1 = require("./logging");
+const constants_1 = require("./constants");
+const resolver_1 = require("./resolver");
+const http = require("http");
+const tls = require("tls");
+const logging = require("./logging");
+const subchannel_address_1 = require("./subchannel-address");
+const uri_parser_1 = require("./uri-parser");
+const url_1 = require("url");
+const resolver_dns_1 = require("./resolver-dns");
+const TRACER_NAME = 'proxy';
+function trace(text) {
+    logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, text);
+}
+function getProxyInfo() {
+    let proxyEnv = '';
+    let envVar = '';
+    /* Prefer using 'grpc_proxy'. Fallback on 'http_proxy' if it is not set.
+     * Also prefer using 'https_proxy' with fallback on 'http_proxy'. The
+     * fallback behavior can be removed if there's a demand for it.
+     */
+    if (process.env.grpc_proxy) {
+        envVar = 'grpc_proxy';
+        proxyEnv = process.env.grpc_proxy;
+    }
+    else if (process.env.https_proxy) {
+        envVar = 'https_proxy';
+        proxyEnv = process.env.https_proxy;
+    }
+    else if (process.env.http_proxy) {
+        envVar = 'http_proxy';
+        proxyEnv = process.env.http_proxy;
+    }
+    else {
+        return {};
+    }
+    let proxyUrl;
+    try {
+        proxyUrl = new url_1.URL(proxyEnv);
+    }
+    catch (e) {
+        (0, logging_1.log)(constants_1.LogVerbosity.ERROR, `cannot parse value of "${envVar}" env var`);
+        return {};
+    }
+    if (proxyUrl.protocol !== 'http:') {
+        (0, logging_1.log)(constants_1.LogVerbosity.ERROR, `"${proxyUrl.protocol}" scheme not supported in proxy URI`);
+        return {};
+    }
+    let userCred = null;
+    if (proxyUrl.username) {
+        if (proxyUrl.password) {
+            (0, logging_1.log)(constants_1.LogVerbosity.INFO, 'userinfo found in proxy URI');
+            userCred = decodeURIComponent(`${proxyUrl.username}:${proxyUrl.password}`);
+        }
+        else {
+            userCred = proxyUrl.username;
+        }
+    }
+    const hostname = proxyUrl.hostname;
+    let port = proxyUrl.port;
+    /* The proxy URL uses the scheme "http:", which has a default port number of
+     * 80. We need to set that explicitly here if it is omitted because otherwise
+     * it will use gRPC's default port 443. */
+    if (port === '') {
+        port = '80';
+    }
+    const result = {
+        address: `${hostname}:${port}`,
+    };
+    if (userCred) {
+        result.creds = userCred;
+    }
+    trace('Proxy server ' + result.address + ' set by environment variable ' + envVar);
+    return result;
+}
+function getNoProxyHostList() {
+    /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
+    let noProxyStr = process.env.no_grpc_proxy;
+    let envVar = 'no_grpc_proxy';
+    if (!noProxyStr) {
+        noProxyStr = process.env.no_proxy;
+        envVar = 'no_proxy';
+    }
+    if (noProxyStr) {
+        trace('No proxy server list set by environment variable ' + envVar);
+        return noProxyStr.split(',');
+    }
+    else {
+        return [];
+    }
+}
+function mapProxyName(target, options) {
+    var _a;
+    const noProxyResult = {
+        target: target,
+        extraOptions: {},
+    };
+    if (((_a = options['grpc.enable_http_proxy']) !== null && _a !== void 0 ? _a : 1) === 0) {
+        return noProxyResult;
+    }
+    if (target.scheme === 'unix') {
+        return noProxyResult;
+    }
+    const proxyInfo = getProxyInfo();
+    if (!proxyInfo.address) {
+        return noProxyResult;
+    }
+    const hostPort = (0, uri_parser_1.splitHostPort)(target.path);
+    if (!hostPort) {
+        return noProxyResult;
+    }
+    const serverHost = hostPort.host;
+    for (const host of getNoProxyHostList()) {
+        if (host === serverHost) {
+            trace('Not using proxy for target in no_proxy list: ' + (0, uri_parser_1.uriToString)(target));
+            return noProxyResult;
+        }
+    }
+    const extraOptions = {
+        'grpc.http_connect_target': (0, uri_parser_1.uriToString)(target),
+    };
+    if (proxyInfo.creds) {
+        extraOptions['grpc.http_connect_creds'] = proxyInfo.creds;
+    }
+    return {
+        target: {
+            scheme: 'dns',
+            path: proxyInfo.address,
+        },
+        extraOptions: extraOptions,
+    };
+}
+exports.mapProxyName = mapProxyName;
+function getProxiedConnection(address, channelOptions, connectionOptions) {
+    var _a;
+    if (!('grpc.http_connect_target' in channelOptions)) {
+        return Promise.resolve({});
+    }
+    const realTarget = channelOptions['grpc.http_connect_target'];
+    const parsedTarget = (0, uri_parser_1.parseUri)(realTarget);
+    if (parsedTarget === null) {
+        return Promise.resolve({});
+    }
+    const splitHostPost = (0, uri_parser_1.splitHostPort)(parsedTarget.path);
+    if (splitHostPost === null) {
+        return Promise.resolve({});
+    }
+    const hostPort = `${splitHostPost.host}:${(_a = splitHostPost.port) !== null && _a !== void 0 ? _a : resolver_dns_1.DEFAULT_PORT}`;
+    const options = {
+        method: 'CONNECT',
+        path: hostPort,
+    };
+    const headers = {
+        Host: hostPort,
+    };
+    // Connect to the subchannel address as a proxy
+    if ((0, subchannel_address_1.isTcpSubchannelAddress)(address)) {
+        options.host = address.host;
+        options.port = address.port;
+    }
+    else {
+        options.socketPath = address.path;
+    }
+    if ('grpc.http_connect_creds' in channelOptions) {
+        headers['Proxy-Authorization'] =
+            'Basic ' +
+                Buffer.from(channelOptions['grpc.http_connect_creds']).toString('base64');
+    }
+    options.headers = headers;
+    const proxyAddressString = (0, subchannel_address_1.subchannelAddressToString)(address);
+    trace('Using proxy ' + proxyAddressString + ' to connect to ' + options.path);
+    return new Promise((resolve, reject) => {
+        const request = http.request(options);
+        request.once('connect', (res, socket, head) => {
+            var _a;
+            request.removeAllListeners();
+            socket.removeAllListeners();
+            if (res.statusCode === 200) {
+                trace('Successfully connected to ' +
+                    options.path +
+                    ' through proxy ' +
+                    proxyAddressString);
+                // The HTTP client may have already read a few bytes of the proxied
+                // connection. If that's the case, put them back into the socket.
+                // See https://github.com/grpc/grpc-node/issues/2744.
+                if (head.length > 0) {
+                    socket.unshift(head);
+                }
+                if ('secureContext' in connectionOptions) {
+                    /* The proxy is connecting to a TLS server, so upgrade this socket
+                     * connection to a TLS connection.
+                     * This is a workaround for https://github.com/nodejs/node/issues/32922
+                     * See https://github.com/grpc/grpc-node/pull/1369 for more info. */
+                    const targetPath = (0, resolver_1.getDefaultAuthority)(parsedTarget);
+                    const hostPort = (0, uri_parser_1.splitHostPort)(targetPath);
+                    const remoteHost = (_a = hostPort === null || hostPort === void 0 ? void 0 : hostPort.host) !== null && _a !== void 0 ? _a : targetPath;
+                    const cts = tls.connect(Object.assign({ host: remoteHost, servername: remoteHost, socket: socket }, connectionOptions), () => {
+                        trace('Successfully established a TLS connection to ' +
+                            options.path +
+                            ' through proxy ' +
+                            proxyAddressString);
+                        resolve({ socket: cts, realTarget: parsedTarget });
+                    });
+                    cts.on('error', (error) => {
+                        trace('Failed to establish a TLS connection to ' +
+                            options.path +
+                            ' through proxy ' +
+                            proxyAddressString +
+                            ' with error ' +
+                            error.message);
+                        reject();
+                    });
+                }
+                else {
+                    trace('Successfully established a plaintext connection to ' +
+                        options.path +
+                        ' through proxy ' +
+                        proxyAddressString);
+                    resolve({
+                        socket,
+                        realTarget: parsedTarget,
+                    });
+                }
+            }
+            else {
+                (0, logging_1.log)(constants_1.LogVerbosity.ERROR, 'Failed to connect to ' +
+                    options.path +
+                    ' through proxy ' +
+                    proxyAddressString +
+                    ' with status ' +
+                    res.statusCode);
+                reject();
+            }
+        });
+        request.once('error', err => {
+            request.removeAllListeners();
+            (0, logging_1.log)(constants_1.LogVerbosity.ERROR, 'Failed to connect to proxy ' +
+                proxyAddressString +
+                ' with error ' +
+                err.message);
+            reject();
+        });
+        request.end();
+    });
+}
+exports.getProxiedConnection = getProxiedConnection;
+//# sourceMappingURL=http_proxy.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/index.js

@@ -0,0 +1,144 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.experimental = exports.ServerInterceptingCall = exports.ResponderBuilder = exports.ServerListenerBuilder = exports.addAdminServicesToServer = exports.getChannelzHandlers = exports.getChannelzServiceDefinition = exports.InterceptorConfigurationError = exports.InterceptingCall = exports.RequesterBuilder = exports.ListenerBuilder = exports.StatusBuilder = exports.getClientChannel = exports.ServerCredentials = exports.Server = exports.setLogVerbosity = exports.setLogger = exports.load = exports.loadObject = exports.CallCredentials = exports.ChannelCredentials = exports.waitForClientReady = exports.closeClient = exports.Channel = exports.makeGenericClientConstructor = exports.makeClientConstructor = exports.loadPackageDefinition = exports.Client = exports.compressionAlgorithms = exports.propagate = exports.connectivityState = exports.status = exports.logVerbosity = exports.Metadata = exports.credentials = void 0;
+const call_credentials_1 = require("./call-credentials");
+Object.defineProperty(exports, "CallCredentials", { enumerable: true, get: function () { return call_credentials_1.CallCredentials; } });
+const channel_1 = require("./channel");
+Object.defineProperty(exports, "Channel", { enumerable: true, get: function () { return channel_1.ChannelImplementation; } });
+const compression_algorithms_1 = require("./compression-algorithms");
+Object.defineProperty(exports, "compressionAlgorithms", { enumerable: true, get: function () { return compression_algorithms_1.CompressionAlgorithms; } });
+const connectivity_state_1 = require("./connectivity-state");
+Object.defineProperty(exports, "connectivityState", { enumerable: true, get: function () { return connectivity_state_1.ConnectivityState; } });
+const channel_credentials_1 = require("./channel-credentials");
+Object.defineProperty(exports, "ChannelCredentials", { enumerable: true, get: function () { return channel_credentials_1.ChannelCredentials; } });
+const client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "logVerbosity", { enumerable: true, get: function () { return constants_1.LogVerbosity; } });
+Object.defineProperty(exports, "status", { enumerable: true, get: function () { return constants_1.Status; } });
+Object.defineProperty(exports, "propagate", { enumerable: true, get: function () { return constants_1.Propagate; } });
+const logging = require("./logging");
+const make_client_1 = require("./make-client");
+Object.defineProperty(exports, "loadPackageDefinition", { enumerable: true, get: function () { return make_client_1.loadPackageDefinition; } });
+Object.defineProperty(exports, "makeClientConstructor", { enumerable: true, get: function () { return make_client_1.makeClientConstructor; } });
+Object.defineProperty(exports, "makeGenericClientConstructor", { enumerable: true, get: function () { return make_client_1.makeClientConstructor; } });
+const metadata_1 = require("./metadata");
+Object.defineProperty(exports, "Metadata", { enumerable: true, get: function () { return metadata_1.Metadata; } });
+const server_1 = require("./server");
+Object.defineProperty(exports, "Server", { enumerable: true, get: function () { return server_1.Server; } });
+const server_credentials_1 = require("./server-credentials");
+Object.defineProperty(exports, "ServerCredentials", { enumerable: true, get: function () { return server_credentials_1.ServerCredentials; } });
+const status_builder_1 = require("./status-builder");
+Object.defineProperty(exports, "StatusBuilder", { enumerable: true, get: function () { return status_builder_1.StatusBuilder; } });
+/**** Client Credentials ****/
+// Using assign only copies enumerable properties, which is what we want
+exports.credentials = {
+    /**
+     * Combine a ChannelCredentials with any number of CallCredentials into a
+     * single ChannelCredentials object.
+     * @param channelCredentials The ChannelCredentials object.
+     * @param callCredentials Any number of CallCredentials objects.
+     * @return The resulting ChannelCredentials object.
+     */
+    combineChannelCredentials: (channelCredentials, ...callCredentials) => {
+        return callCredentials.reduce((acc, other) => acc.compose(other), channelCredentials);
+    },
+    /**
+     * Combine any number of CallCredentials into a single CallCredentials
+     * object.
+     * @param first The first CallCredentials object.
+     * @param additional Any number of additional CallCredentials objects.
+     * @return The resulting CallCredentials object.
+     */
+    combineCallCredentials: (first, ...additional) => {
+        return additional.reduce((acc, other) => acc.compose(other), first);
+    },
+    // from channel-credentials.ts
+    createInsecure: channel_credentials_1.ChannelCredentials.createInsecure,
+    createSsl: channel_credentials_1.ChannelCredentials.createSsl,
+    createFromSecureContext: channel_credentials_1.ChannelCredentials.createFromSecureContext,
+    // from call-credentials.ts
+    createFromMetadataGenerator: call_credentials_1.CallCredentials.createFromMetadataGenerator,
+    createFromGoogleCredential: call_credentials_1.CallCredentials.createFromGoogleCredential,
+    createEmpty: call_credentials_1.CallCredentials.createEmpty,
+};
+/**
+ * Close a Client object.
+ * @param client The client to close.
+ */
+const closeClient = (client) => client.close();
+exports.closeClient = closeClient;
+const waitForClientReady = (client, deadline, callback) => client.waitForReady(deadline, callback);
+exports.waitForClientReady = waitForClientReady;
+/* eslint-enable @typescript-eslint/no-explicit-any */
+/**** Unimplemented function stubs ****/
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const loadObject = (value, options) => {
+    throw new Error('Not available in this library. Use @grpc/proto-loader and loadPackageDefinition instead');
+};
+exports.loadObject = loadObject;
+const load = (filename, format, options) => {
+    throw new Error('Not available in this library. Use @grpc/proto-loader and loadPackageDefinition instead');
+};
+exports.load = load;
+const setLogger = (logger) => {
+    logging.setLogger(logger);
+};
+exports.setLogger = setLogger;
+const setLogVerbosity = (verbosity) => {
+    logging.setLoggerVerbosity(verbosity);
+};
+exports.setLogVerbosity = setLogVerbosity;
+const getClientChannel = (client) => {
+    return client_1.Client.prototype.getChannel.call(client);
+};
+exports.getClientChannel = getClientChannel;
+var client_interceptors_1 = require("./client-interceptors");
+Object.defineProperty(exports, "ListenerBuilder", { enumerable: true, get: function () { return client_interceptors_1.ListenerBuilder; } });
+Object.defineProperty(exports, "RequesterBuilder", { enumerable: true, get: function () { return client_interceptors_1.RequesterBuilder; } });
+Object.defineProperty(exports, "InterceptingCall", { enumerable: true, get: function () { return client_interceptors_1.InterceptingCall; } });
+Object.defineProperty(exports, "InterceptorConfigurationError", { enumerable: true, get: function () { return client_interceptors_1.InterceptorConfigurationError; } });
+var channelz_1 = require("./channelz");
+Object.defineProperty(exports, "getChannelzServiceDefinition", { enumerable: true, get: function () { return channelz_1.getChannelzServiceDefinition; } });
+Object.defineProperty(exports, "getChannelzHandlers", { enumerable: true, get: function () { return channelz_1.getChannelzHandlers; } });
+var admin_1 = require("./admin");
+Object.defineProperty(exports, "addAdminServicesToServer", { enumerable: true, get: function () { return admin_1.addAdminServicesToServer; } });
+var server_interceptors_1 = require("./server-interceptors");
+Object.defineProperty(exports, "ServerListenerBuilder", { enumerable: true, get: function () { return server_interceptors_1.ServerListenerBuilder; } });
+Object.defineProperty(exports, "ResponderBuilder", { enumerable: true, get: function () { return server_interceptors_1.ResponderBuilder; } });
+Object.defineProperty(exports, "ServerInterceptingCall", { enumerable: true, get: function () { return server_interceptors_1.ServerInterceptingCall; } });
+const experimental = require("./experimental");
+exports.experimental = experimental;
+const resolver_dns = require("./resolver-dns");
+const resolver_uds = require("./resolver-uds");
+const resolver_ip = require("./resolver-ip");
+const load_balancer_pick_first = require("./load-balancer-pick-first");
+const load_balancer_round_robin = require("./load-balancer-round-robin");
+const load_balancer_outlier_detection = require("./load-balancer-outlier-detection");
+const channelz = require("./channelz");
+(() => {
+    resolver_dns.setup();
+    resolver_uds.setup();
+    resolver_ip.setup();
+    load_balancer_pick_first.setup();
+    load_balancer_round_robin.setup();
+    load_balancer_outlier_detection.setup();
+    channelz.setup();
+})();
+//# sourceMappingURL=index.js.map