plugin-cluster-manager 1.0.12

package/dist/node_modules/@kubernetes/client-node/dist/informer.d.ts

@@ -0,0 +1,32 @@
+import { ObjectCache } from './cache';
+import { KubeConfig } from './config';
+import { KubernetesListObject, KubernetesObject } from './types';
+import http = require('http');
+export type ObjectCallback<T extends KubernetesObject> = (obj: T) => void;
+export type ErrorCallback = (err?: any) => void;
+export type ListCallback<T extends KubernetesObject> = (list: T[], ResourceVersion: string) => void;
+export type ListPromise<T extends KubernetesObject> = () => Promise<{
+    response: http.IncomingMessage;
+    body: KubernetesListObject<T>;
+}>;
+export declare const ADD = "add";
+export type ADD = typeof ADD;
+export declare const UPDATE = "update";
+export type UPDATE = typeof UPDATE;
+export declare const CHANGE = "change";
+export type CHANGE = typeof CHANGE;
+export declare const DELETE = "delete";
+export type DELETE = typeof DELETE;
+export declare const CONNECT = "connect";
+export type CONNECT = typeof CONNECT;
+export declare const ERROR = "error";
+export type ERROR = typeof ERROR;
+export interface Informer<T extends KubernetesObject> {
+    on(verb: ADD | UPDATE | DELETE | CHANGE, cb: ObjectCallback<T>): void;
+    on(verb: ERROR | CONNECT, cb: ErrorCallback): void;
+    off(verb: ADD | UPDATE | DELETE | CHANGE, cb: ObjectCallback<T>): void;
+    off(verb: ERROR | CONNECT, cb: ErrorCallback): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function makeInformer<T extends KubernetesObject>(kubeconfig: KubeConfig, path: string, listPromiseFn: ListPromise<T>, labelSelector?: string, fieldSelector?: string): Informer<T> & ObjectCache<T>;

package/dist/node_modules/@kubernetes/client-node/dist/informer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR = exports.CONNECT = exports.DELETE = exports.CHANGE = exports.UPDATE = exports.ADD = void 0;
+exports.makeInformer = makeInformer;
+const cache_1 = require("./cache");
+const watch_1 = require("./watch");
+// These are issued per object
+exports.ADD = 'add';
+exports.UPDATE = 'update';
+exports.CHANGE = 'change';
+exports.DELETE = 'delete';
+// This is issued when a watch connects or reconnects
+exports.CONNECT = 'connect';
+// This is issued when there is an error
+exports.ERROR = 'error';
+function makeInformer(kubeconfig, path, listPromiseFn, labelSelector, fieldSelector) {
+    const watch = new watch_1.Watch(kubeconfig);
+    return new cache_1.ListWatch(path, watch, listPromiseFn, false, labelSelector, fieldSelector);
+}
+//# sourceMappingURL=informer.js.map

package/dist/node_modules/@kubernetes/client-node/dist/json_path.d.ts

@@ -0,0 +1 @@
+export declare function jsonpath(path: string, json: object): any;

package/dist/node_modules/@kubernetes/client-node/dist/json_path.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonpath = jsonpath;
+const jsonpath_plus_1 = require("jsonpath-plus");
+function jsonpath(path, json) {
+    return (0, jsonpath_plus_1.JSONPath)({
+        path,
+        json,
+        eval: false,
+    });
+}
+//# sourceMappingURL=json_path.js.map

package/dist/node_modules/@kubernetes/client-node/dist/log.d.ts

@@ -0,0 +1,44 @@
+import request = require('request');
+import { Writable } from 'stream';
+import { KubeConfig } from './config';
+export interface LogOptions {
+    /**
+     * Follow the log stream of the pod. Defaults to false.
+     */
+    follow?: boolean;
+    /**
+     * If set, the number of bytes to read from the server before terminating the log output. This may not display a
+     * complete final line of logging, and may return slightly more or slightly less than the specified limit.
+     */
+    limitBytes?: number;
+    /**
+     * If true, then the output is pretty printed.
+     */
+    pretty?: boolean;
+    /**
+     * Return previous terminated container logs. Defaults to false.
+     */
+    previous?: boolean;
+    /**
+     * A relative time in seconds before the current time from which to show logs. If this value precedes the time a
+     * pod was started, only logs since the pod start will be returned. If this value is in the future, no logs will
+     * be returned. Only one of sinceSeconds or sinceTime may be specified.
+     */
+    sinceSeconds?: number;
+    /**
+     * If set, the number of lines from the end of the logs to show. If not specified, logs are shown from the creation
+     * of the container or sinceSeconds or sinceTime
+     */
+    tailLines?: number;
+    /**
+     * If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output. Defaults to false.
+     */
+    timestamps?: boolean;
+}
+export declare class Log {
+    config: KubeConfig;
+    constructor(config: KubeConfig);
+    log(namespace: string, podName: string, containerName: string, stream: Writable, options?: LogOptions): Promise<request.Request>;
+    /** @deprecated done callback is deprecated */
+    log(namespace: string, podName: string, containerName: string, stream: Writable, done: (err: any) => void, options?: LogOptions): Promise<request.Request>;
+}

package/dist/node_modules/@kubernetes/client-node/dist/log.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const request = require("request");
+const api_1 = require("./gen/api");
+class Log {
+    constructor(config) {
+        this.config = config;
+    }
+    async log(namespace, podName, containerName, stream, doneOrOptions, options) {
+        let done = () => undefined;
+        if (typeof doneOrOptions === 'function') {
+            done = doneOrOptions;
+        }
+        else {
+            options = doneOrOptions;
+        }
+        const path = `/api/v1/namespaces/${namespace}/pods/${podName}/log`;
+        const cluster = this.config.getCurrentCluster();
+        if (!cluster) {
+            throw new Error('No currently active cluster');
+        }
+        const url = cluster.server + path;
+        const requestOptions = {
+            method: 'GET',
+            qs: {
+                ...options,
+                container: containerName,
+            },
+            uri: url,
+        };
+        await this.config.applyToRequest(requestOptions);
+        return new Promise((resolve, reject) => {
+            const req = request(requestOptions, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                    done(error);
+                }
+                else if (response.statusCode !== 200) {
+                    try {
+                        const deserializedBody = api_1.ObjectSerializer.deserialize(JSON.parse(body), 'V1Status');
+                        reject(new api_1.HttpError(response, deserializedBody, response.statusCode));
+                    }
+                    catch (e) {
+                        reject(new api_1.HttpError(response, body, response.statusCode));
+                    }
+                    done(body);
+                }
+                else {
+                    done(null);
+                }
+            }).on('response', (response) => {
+                if (response.statusCode === 200) {
+                    req.pipe(stream);
+                    resolve(req);
+                }
+            });
+        });
+    }
+}
+exports.Log = Log;
+//# sourceMappingURL=log.js.map

package/dist/node_modules/@kubernetes/client-node/dist/metrics.d.ts

@@ -0,0 +1,76 @@
+import { KubeConfig } from './config';
+export interface Usage {
+    cpu: string;
+    memory: string;
+}
+export interface ContainerMetric {
+    name: string;
+    usage: Usage;
+}
+export interface PodMetric {
+    metadata: {
+        name: string;
+        namespace: string;
+        selfLink?: string;
+        creationTimestamp: string;
+        labels?: {
+            [key: string]: string;
+        };
+    };
+    timestamp: string;
+    window: string;
+    containers: ContainerMetric[];
+}
+export interface NodeMetric {
+    metadata: {
+        name: string;
+        selfLink?: string;
+        creationTimestamp: string;
+        labels?: {
+            [key: string]: string;
+        };
+    };
+    timestamp: string;
+    window: string;
+    usage: Usage;
+}
+export interface PodMetricsList {
+    kind: 'PodMetricsList';
+    apiVersion: 'metrics.k8s.io/v1beta1';
+    metadata: {
+        selfLink: string;
+    };
+    items: PodMetric[];
+}
+export interface NodeMetricsList {
+    kind: 'NodeMetricsList';
+    apiVersion: 'metrics.k8s.io/v1beta1';
+    metadata: {
+        selfLink: string;
+    };
+    items: NodeMetric[];
+}
+export interface SinglePodMetrics extends PodMetric {
+    kind: 'PodMetrics';
+    apiVersion: 'metrics.k8s.io/v1beta1';
+}
+export interface SingleNodeMetrics extends NodeMetric {
+    kind: 'NodeMetrics';
+    apiVersion: 'metrics.k8s.io/v1beta1';
+}
+export interface MetricsOptions {
+    /**
+     * restrict the list of returned objects by labels
+     */
+    labelSelector?: string;
+}
+export declare class Metrics {
+    private config;
+    constructor(config: KubeConfig);
+    getNodeMetrics(options?: MetricsOptions): Promise<NodeMetricsList>;
+    getNodeMetrics(node: string, options?: MetricsOptions): Promise<SingleNodeMetrics>;
+    getPodMetrics(options?: MetricsOptions): Promise<PodMetricsList>;
+    getPodMetrics(namespace?: string, options?: MetricsOptions): Promise<PodMetricsList>;
+    getPodMetrics(namespace: string, name: string, options?: MetricsOptions): Promise<SinglePodMetrics>;
+    private metricsApiRequest;
+}

package/dist/node_modules/@kubernetes/client-node/dist/metrics.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metrics = void 0;
+const request = require("request");
+const api_1 = require("./gen/api");
+class Metrics {
+    constructor(config) {
+        this.config = config;
+    }
+    async getNodeMetrics(nodeOrOptions, options) {
+        if (typeof nodeOrOptions !== 'string' || nodeOrOptions === '') {
+            if (nodeOrOptions !== '') {
+                options = nodeOrOptions;
+            }
+            return this.metricsApiRequest('/apis/metrics.k8s.io/v1beta1/nodes', options);
+        }
+        return this.metricsApiRequest(`/apis/metrics.k8s.io/v1beta1/nodes/${nodeOrOptions}`, options);
+    }
+    async getPodMetrics(namespaceOrOptions, nameOrOptions, options) {
+        let path;
+        if (typeof namespaceOrOptions === 'string' && namespaceOrOptions !== '') {
+            const namespace = namespaceOrOptions;
+            if (typeof nameOrOptions === 'string') {
+                path = `/apis/metrics.k8s.io/v1beta1/namespaces/${namespace}/pods/${nameOrOptions}`;
+            }
+            else {
+                path = `/apis/metrics.k8s.io/v1beta1/namespaces/${namespace}/pods`;
+                options = nameOrOptions;
+            }
+        }
+        else {
+            path = '/apis/metrics.k8s.io/v1beta1/pods';
+            if (typeof namespaceOrOptions !== 'string') {
+                options = namespaceOrOptions;
+            }
+            else if (typeof nameOrOptions !== 'string') {
+                options = nameOrOptions;
+            }
+        }
+        return this.metricsApiRequest(path, options);
+    }
+    async metricsApiRequest(path, options) {
+        const cluster = this.config.getCurrentCluster();
+        if (!cluster) {
+            throw new Error('No currently active cluster');
+        }
+        const requestOptions = {
+            method: 'GET',
+            uri: cluster.server + path,
+            qs: options,
+        };
+        await this.config.applyToRequest(requestOptions);
+        return new Promise((resolve, reject) => {
+            const req = request(requestOptions, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (response.statusCode !== 200) {
+                    try {
+                        const deserializedBody = api_1.ObjectSerializer.deserialize(JSON.parse(body), 'V1Status');
+                        reject(new api_1.HttpError(response, deserializedBody, response.statusCode));
+                    }
+                    catch (e) {
+                        reject(new api_1.HttpError(response, body, response.statusCode));
+                    }
+                }
+                else {
+                    resolve(JSON.parse(body));
+                }
+            });
+        });
+    }
+}
+exports.Metrics = Metrics;
+//# sourceMappingURL=metrics.js.map

package/dist/node_modules/@kubernetes/client-node/dist/object.d.ts

@@ -0,0 +1,302 @@
+import * as http from 'http';
+import request = require('request');
+import { ApisApi, V1APIResource, V1APIResourceList, V1DeleteOptions, V1Status } from './api';
+import { KubeConfig } from './config';
+import { KubernetesListObject, KubernetesObject } from './types';
+import { Watch } from './watch';
+/** Union type of body types returned by KubernetesObjectApi. */
+type KubernetesObjectResponseBody = KubernetesObject | KubernetesListObject<KubernetesObject> | V1Status | V1APIResourceList;
+/** Kubernetes API verbs. */
+type KubernetesApiAction = 'create' | 'delete' | 'patch' | 'read' | 'list' | 'replace';
+type KubernetesObjectHeader<T extends KubernetesObject | KubernetesObject> = Pick<T, 'apiVersion' | 'kind'> & {
+    metadata: {
+        name: string;
+        namespace?: string;
+    };
+};
+interface GroupVersion {
+    group: string;
+    version: string;
+}
+/**
+ * Describes the type of an watch event.
+ * Object is:
+ * - If Type is Added or Modified: the new state of the object.
+ * - If Type is Deleted: the state of the object immediately before deletion.
+ * - If Type is Bookmark: the object (instance of a type being watched) where
+ *   only ResourceVersion field is set. On successful restart of watch from a
+ *   bookmark resourceVersion, client is guaranteed to not get repeat event
+ *   nor miss any events.
+ * - If Type is Error: *api.Status is recommended; other types may make sense
+ *   depending on context.
+ */
+export declare enum KubernetesEventType {
+    ADDED = "ADDED",
+    MODIFIED = "MODIFIED",
+    DELETED = "DELETED",
+    BOOKMARK = "BOOKMARK",
+    ERROR = "ERROR"
+}
+export type WatchObject<T extends KubernetesObject | KubernetesObject> = {
+    type: KubernetesEventType;
+    object: T;
+};
+export type WatchCallback<T extends KubernetesObject | KubernetesObject> = (phase: KubernetesEventType, apiObj: T, watchObj?: WatchObject<T>) => void;
+export type WatchOptions = {
+    /**
+     * To mitigate the impact of short history window,
+     * the Kubernetes API provides a watch event named BOOKMARK.
+     * It is a special kind of event to mark that all changes
+     * up to a given resourceVersion the client is requesting
+     * have already been sent.
+     *
+     * See https://kubernetes.io/docs/reference/using-api/api-concepts/#watch-bookmarks
+     */
+    allowWatchBookmarks?: boolean;
+    /**
+     * Start watch at the given resource version.
+     * Starting at a specific resource version means that only events
+     * starting from that versions are included in the watch stream.
+     */
+    resourceVersion?: string;
+};
+export type WatchResult = {
+    abort: () => void;
+};
+/**
+ * Dynamically construct Kubernetes API request URIs so client does not have to know what type of object it is acting
+ * on.
+ */
+export declare class KubernetesObjectApi extends ApisApi {
+    /**
+     * Create a KubernetesObjectApi object from the provided KubeConfig.  This method should be used rather than
+     * [[KubeConfig.makeApiClient]] so we can properly determine the default namespace if one is provided by the current
+     * context.
+     *
+     * @param kc Valid Kubernetes config
+     * @return Properly instantiated [[KubernetesObjectApi]] object
+     */
+    static makeApiClient(kc: KubeConfig): KubernetesObjectApi;
+    /** Initialize the default namespace.  May be overwritten by context. */
+    protected defaultNamespace: string;
+    /** Cache resource API response. */
+    protected apiVersionResourceCache: Record<string, V1APIResourceList>;
+    protected watcher?: Watch;
+    /**
+     * Create any Kubernetes resource.
+     * @param spec Kubernetes resource spec.
+     * @param pretty If \&#39;true\&#39;, then the output is pretty printed.
+     * @param dryRun When present, indicates that modifications should not be persisted. An invalid or unrecognized
+     *        dryRun directive will result in an error response and no further processing of the request. Valid values
+     *        are: - All: all dry run stages will be processed
+     * @param fieldManager fieldManager is a name associated with the actor or entity that is making these changes. The
+     *        value must be less than or 128 characters long, and only contain printable characters, as defined by
+     *        https://golang.org/pkg/unicode/#IsPrint.
+     * @param options Optional headers to use in the request.
+     * @return Promise containing the request response and [[KubernetesObject]].
+     */
+    create<T extends KubernetesObject | KubernetesObject>(spec: T, pretty?: string, dryRun?: string, fieldManager?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: T;
+        response: http.IncomingMessage;
+    }>;
+    /**
+     * Delete any Kubernetes resource.
+     * @param spec Kubernetes resource spec
+     * @param pretty If \&#39;true\&#39;, then the output is pretty printed.
+     * @param dryRun When present, indicates that modifications should not be persisted. An invalid or unrecognized
+     *        dryRun directive will result in an error response and no further processing of the request. Valid values
+     *        are: - All: all dry run stages will be processed
+     * @param gracePeriodSeconds The duration in seconds before the object should be deleted. Value must be non-negative
+     *        integer. The value zero indicates delete immediately. If this value is nil, the default grace period for
+     *        the specified type will be used. Defaults to a per object value if not specified. zero means delete
+     *        immediately.
+     * @param orphanDependents Deprecated: please use the PropagationPolicy, this field will be deprecated in
+     *        1.7. Should the dependent objects be orphaned. If true/false, the \&quot;orphan\&quot; finalizer will be
+     *        added to/removed from the object\&#39;s finalizers list. Either this field or PropagationPolicy may be
+     *        set, but not both.
+     * @param propagationPolicy Whether and how garbage collection will be performed. Either this field or
+     *        OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in
+     *        the metadata.finalizers and the resource-specific default policy. Acceptable values are:
+     *        \&#39;Orphan\&#39; - orphan the dependents; \&#39;Background\&#39; - allow the garbage collector to delete
+     *        the dependents in the background; \&#39;Foreground\&#39; - a cascading policy that deletes all dependents
+     *        in the foreground.
+     * @param body See [[V1DeleteOptions]].
+     * @param options Optional headers to use in the request.
+     * @return Promise containing the request response and a Kubernetes [[V1Status]].
+     */
+    delete(spec: KubernetesObject, pretty?: string, dryRun?: string, gracePeriodSeconds?: number, orphanDependents?: boolean, propagationPolicy?: string, body?: V1DeleteOptions, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: V1Status;
+        response: http.IncomingMessage;
+    }>;
+    /**
+     * Patch any Kubernetes resource.
+     * @param spec Kubernetes resource spec
+     * @param pretty If \&#39;true\&#39;, then the output is pretty printed.
+     * @param dryRun When present, indicates that modifications should not be persisted. An invalid or unrecognized
+     *        dryRun directive will result in an error response and no further processing of the request. Valid values
+     *        are: - All: all dry run stages will be processed
+     * @param fieldManager fieldManager is a name associated with the actor or entity that is making these changes.  The
+     *        value must be less than or 128 characters long, and only contain printable characters, as defined by
+     *        https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests
+     *        (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch,
+     *        StrategicMergePatch).
+     * @param force Force is going to \&quot;force\&quot; Apply requests.  It means user will re-acquire conflicting
+     *        fields owned by other people. Force flag must be unset for non-apply patch requests.
+     * @param options Optional headers to use in the request.
+     * @return Promise containing the request response and [[KubernetesObject]].
+     */
+    patch<T extends KubernetesObject | KubernetesObject>(spec: T, pretty?: string, dryRun?: string, fieldManager?: string, force?: boolean, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: T;
+        response: http.IncomingMessage;
+    }>;
+    /**
+     * Read any Kubernetes resource.
+     * @param spec Kubernetes resource spec
+     * @param pretty If \&#39;true\&#39;, then the output is pretty printed.
+     * @param exact Should the export be exact.  Exact export maintains cluster-specific fields like
+     *        \&#39;Namespace\&#39;. Deprecated. Planned for removal in 1.18.
+     * @param exportt Should this value be exported.  Export strips fields that a user can not
+     *        specify. Deprecated. Planned for removal in 1.18.
+     * @param options Optional headers to use in the request.
+     * @return Promise containing the request response and [[KubernetesObject]].
+     */
+    read<T extends KubernetesObject | KubernetesObject>(spec: KubernetesObjectHeader<T>, pretty?: string, exact?: boolean, exportt?: boolean, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: T;
+        response: http.IncomingMessage;
+    }>;
+    /**
+     * List any Kubernetes resources.
+     * @param apiVersion api group and version of the form <apiGroup>/<version>
+     * @param kind Kubernetes resource kind
+     * @param namespace list resources in this namespace
+     * @param pretty If \&#39;true\&#39;, then the output is pretty printed.
+     * @param exact Should the export be exact.  Exact export maintains cluster-specific fields like
+     *        \&#39;Namespace\&#39;. Deprecated. Planned for removal in 1.18.
+     * @param exportt Should this value be exported.  Export strips fields that a user can not
+     *        specify. Deprecated. Planned for removal in 1.18.
+     * @param fieldSelector A selector to restrict the list of returned objects by their fields. Defaults to everything.
+     * @param labelSelector A selector to restrict the list of returned objects by their labels. Defaults to everything.
+     * @param limit Number of returned resources.
+     * @param options Optional headers to use in the request.
+     * @return Promise containing the request response and [[KubernetesListObject<KubernetesObject>]].
+     */
+    list<T extends KubernetesObject | KubernetesObject>(apiVersion: string, kind: string, namespace?: string, pretty?: string, exact?: boolean, exportt?: boolean, fieldSelector?: string, labelSelector?: string, limit?: number, continueToken?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: KubernetesListObject<T>;
+        response: http.IncomingMessage;
+    }>;
+    /**
+     * Replace any Kubernetes resource.
+     * @param spec Kubernetes resource spec
+     * @param pretty If \&#39;true\&#39;, then the output is pretty printed.
+     * @param dryRun When present, indicates that modifications should not be persisted. An invalid or unrecognized
+     *        dryRun directive will result in an error response and no further processing of the request. Valid values
+     *        are: - All: all dry run stages will be processed
+     * @param fieldManager fieldManager is a name associated with the actor or entity that is making these changes. The
+     *        value must be less than or 128 characters long, and only contain printable characters, as defined by
+     *        https://golang.org/pkg/unicode/#IsPrint.
+     * @param options Optional headers to use in the request.
+     * @return Promise containing the request response and [[KubernetesObject]].
+     */
+    replace<T extends KubernetesObject | KubernetesObject>(spec: T, pretty?: string, dryRun?: string, fieldManager?: string, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<{
+        body: T;
+        response: http.IncomingMessage;
+    }>;
+    /**
+     * Watches the given resources and calls provided callback with the parsed json object
+     * upon event received over the watcher connection.
+     *
+     * @param resource defines the resources to watch. Namespace is optional.
+     *                 Undefined namespace means to watch all namespaces.
+     * @param options Optional options that are passed to the watch request.
+     * @param callback callback function that is called with the parsed json object upon event received.
+     * @param done callback is called either when connection is closed or when there
+     *             is an error. In either case, watcher takes care of properly closing the
+     *             underlaying connection so that it doesn't leak any resources.
+     *
+     * @returns WatchResult object that can be used to abort the watch.
+     */
+    watch<T extends KubernetesObject | KubernetesObject>({ resource, options, callback, done, }: {
+        resource: {
+            apiVersion: string;
+            kind: string;
+            namespace?: string;
+        };
+        options?: WatchOptions;
+        callback: WatchCallback<T>;
+        done: (err: unknown) => void;
+    }): Promise<WatchResult>;
+    /** Set default namespace from current context, if available. */
+    protected setDefaultNamespace(kc: KubeConfig): string;
+    /**
+     * Use spec information to construct resource URI path.  If any required information in not provided, an Error is
+     * thrown.  If an `apiVersion` is not provided, 'v1' is used.  If a `metadata.namespace` is not provided for a
+     * request that requires one, the context default is used, if available, if not, 'default' is used.
+     *
+     * @param spec Kubernetes resource spec which must define kind and apiVersion properties.
+     * @param action API action, see [[K8sApiAction]].
+     * @return tail of resource-specific URI
+     */
+    protected specUriPath(spec: KubernetesObject, action: KubernetesApiAction): Promise<string>;
+    /** Return root of API path up to API version. */
+    protected apiVersionPath(apiVersion: string): string;
+    /**
+     * Merge default headers and provided headers, setting the 'Accept' header to 'application/json' and, if the
+     * `action` is 'PATCH', the 'Content-Type' header to [[KubernetesPatchStrategies.StrategicMergePatch]].  Both of
+     * these defaults can be overriden by values provided in `optionsHeaders`.
+     *
+     * @param optionHeaders Headers from method's options argument.
+     * @param action HTTP action headers are being generated for.
+     * @return Headers to use in request.
+     */
+    protected generateHeaders(optionsHeaders: {
+        [name: string]: string;
+    }, action?: string): {
+        [name: string]: string;
+    };
+    /**
+     * Get metadata from Kubernetes API for resources described by `kind` and `apiVersion`.  If it is unable to find the
+     * resource `kind` under the provided `apiVersion`, `undefined` is returned.
+     *
+     * This method caches responses from the Kubernetes API to use for future requests.  If the cache for apiVersion
+     * exists but the kind is not found the request is attempted again.
+     *
+     * @param apiVersion Kubernetes API version, e.g., 'v1' or 'apps/v1'.
+     * @param kind Kubernetes resource kind, e.g., 'Pod' or 'Namespace'.
+     * @return Promise of the resource metadata or `undefined` if the resource is not found.
+     */
+    protected resource(apiVersion: string, kind: string): Promise<V1APIResource | undefined>;
+    protected getSerializationType(apiVersion?: string, kind?: string): Promise<string>;
+    protected groupVersion(apiVersion: string): GroupVersion;
+    /**
+     * Standard Kubernetes request wrapped in a Promise.
+     */
+    protected requestPromise<T extends KubernetesObjectResponseBody = KubernetesObject>(requestOptions: request.Options, type?: string): Promise<{
+        body: T;
+        response: http.IncomingMessage;
+    }>;
+}
+export {};