@codiac.io/codiac-cli 1.2.174 → 1.2.202

package/dist/apis/codiac-relay/common/utils.d.ts

@@ -0,0 +1,23 @@
+export declare class utils {
+    /** Returns the instantiated object or array.
+     * Returns undefined for both an empty or missing source file.
+     * Uses JSON.parse and does not perform any explicit casting.
+     * Throws encountered exceptions.  Resolves tilde (~) path prefixes.
+     * @param pathName Fully qualified path and filename of the json file.
+     * @param allowComments (default: false) Flag to use a json comment parser to support comments in the json file.
+     */
+    static deserializeJsonFile<T>(pathName: string, allowComments?: boolean): T | undefined;
+    /** Uses JSON.stringify() to write the given object to a file.  Resolves tilde (~) path prefixes.
+     * @param subject The object to serialize.
+     * @param pathName Fully-qualified path and filename (eg "/users/JoeCool/.config/app-config.json").
+     * @param allowComments (default: false) Flag to use a json comment parser to support comments in the json file.
+     */
+    static serializeJsonFile(subject: any, pathName: string, allowComments?: boolean): void;
+    /** Replaces the leading tilde (~) in the given file path
+     * with the absolute path to the os.homedir (eg: "/Users/JoeCool").
+     * NOTE:  Relative paths will slide through this function untouched:
+     * this function does not necessarily return an absolute path! */
+    static resolveHomeDir(pathName: string): string;
+    /**  */
+    static smashMergeConfg<TSettings>(defaults: TSettings, configsInPriorityOrder?: Partial<TSettings>[]): TSettings;
+}

package/dist/apis/codiac-relay/common/utils.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = void 0;
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const commentJson = require("comment-json");
+const _ = require("lodash");
+// TODO:  Promote this to a shared pkg
+class utils {
+    /** Returns the instantiated object or array.
+     * Returns undefined for both an empty or missing source file.
+     * Uses JSON.parse and does not perform any explicit casting.
+     * Throws encountered exceptions.  Resolves tilde (~) path prefixes.
+     * @param pathName Fully qualified path and filename of the json file.
+     * @param allowComments (default: false) Flag to use a json comment parser to support comments in the json file.
+     */
+    static deserializeJsonFile(pathName, allowComments = false) {
+        try {
+            let targetPathName = this.resolveHomeDir(pathName);
+            if (!path.isAbsolute(targetPathName)) {
+                throw new Error(`Cannot deserialize: the pathName [${pathName}] is not a fully qualified path.`);
+            }
+            if (fs.existsSync(targetPathName)) {
+                let json = fs.readFileSync(targetPathName, { encoding: 'utf-8' });
+                if (allowComments) {
+                    let obj = commentJson.parse(json);
+                    return obj;
+                }
+                else {
+                    let obj = JSON.parse(json);
+                    return obj;
+                }
+            }
+            else {
+                return undefined;
+            }
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    /** Uses JSON.stringify() to write the given object to a file.  Resolves tilde (~) path prefixes.
+     * @param subject The object to serialize.
+     * @param pathName Fully-qualified path and filename (eg "/users/JoeCool/.config/app-config.json").
+     * @param allowComments (default: false) Flag to use a json comment parser to support comments in the json file.
+     */
+    static serializeJsonFile(subject, pathName, allowComments = false) {
+        let targetPathName = this.resolveHomeDir(pathName);
+        if (!path.isAbsolute(targetPathName)) {
+            throw new Error(`Cannot serialize: the pathName [${pathName}] is not a fully qaulified path`);
+        }
+        if (allowComments) {
+            commentJson.stringify(subject, undefined, '  ');
+        }
+        else {
+            fs.writeFileSync(targetPathName, JSON.stringify(subject, undefined, '  '));
+        }
+    }
+    /** Replaces the leading tilde (~) in the given file path
+     * with the absolute path to the os.homedir (eg: "/Users/JoeCool").
+     * NOTE:  Relative paths will slide through this function untouched:
+     * this function does not necessarily return an absolute path! */
+    static resolveHomeDir(pathName) {
+        if (pathName.startsWith("~")) {
+            return path.join(os.homedir(), pathName.slice(2));
+        }
+        else {
+            return pathName;
+        }
+    }
+    /**  */
+    static smashMergeConfg(defaults, configsInPriorityOrder) {
+        if (!configsInPriorityOrder || configsInPriorityOrder.length == 0)
+            return defaults;
+        else {
+            let ultimate = _.assignIn(defaults, ...configsInPriorityOrder.reverse());
+            return ultimate;
+        }
+    }
+}
+exports.utils = utils;
+//# sourceMappingURL=utils.js.map

package/dist/apis/codiac-relay/contracts/index.d.ts

@@ -0,0 +1 @@
+export * from "../gen/contracts";

package/dist/apis/codiac-relay/contracts/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../gen/contracts"), exports);
+//# sourceMappingURL=index.js.map

package/dist/apis/codiac-relay/gen/client-config.d.ts

@@ -0,0 +1,10 @@
+/** The in-memory representation of the api client config file.
+ */
+export declare class RelayClientConfig {
+    static readonly CONFIG_PATH: string;
+    static readonly CONFIG_FILENAME = "config.json";
+    private static loader;
+    static load(): RelayClientConfig | undefined;
+    constructor();
+    apiBaseUrl: string | undefined;
+}

package/dist/apis/codiac-relay/gen/client-config.js

@@ -0,0 +1,29 @@
+"use strict";
+var RelayClientConfig_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelayClientConfig = void 0;
+const tslib_1 = require("tslib");
+const os = require("os");
+const path = require("path");
+const inversify_1 = require("inversify");
+const config_loader_1 = require("../common/config-loader");
+/** The in-memory representation of the api client config file.
+ */
+let RelayClientConfig = RelayClientConfig_1 = class RelayClientConfig {
+    constructor() {
+    }
+    static load() {
+        const os = require('os');
+        let cfg = this.loader.load(); // yeah this is real helpful - maybe we should just accept the .loader.load() syntax and expose the loader itself?
+        return cfg;
+    }
+};
+RelayClientConfig.CONFIG_PATH = path.posix.join(os.homedir(), `.config`, `codiac-api-client`);
+RelayClientConfig.CONFIG_FILENAME = "config.json";
+RelayClientConfig.loader = new config_loader_1.ConfigLoader(RelayClientConfig_1.CONFIG_PATH, RelayClientConfig_1.CONFIG_FILENAME);
+RelayClientConfig = RelayClientConfig_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], RelayClientConfig);
+exports.RelayClientConfig = RelayClientConfig;
+//# sourceMappingURL=client-config.js.map

package/dist/apis/codiac-relay/gen/client-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-config.js","sourceRoot":"","sources":["../../../../src/apis/codiac-relay/gen/client-config.ts"],"names":[],"mappings":";;;;;AAAA,yBAAyB;AACzB,6BAA6B;AAC7B,yCAAuC;AACvC,2DAAuD;AAGvD;GACG;AAEH,IAAa,iBAAiB,yBAA9B,MAAa,iBAAiB;IAY5B;IAEA,CAAC;IATD,MAAM,CAAC,IAAI;QACT,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAEzB,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAE,kHAAkH;QACjJ,OAAO,GAAG,CAAC;IACb,CAAC;CAMF,CAAA;AAfwB,6BAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,mBAAmB,CAAE,CAAA;AAC5E,iCAAe,GAAG,aAAc,CAAA;AACxC,wBAAM,GAAG,IAAI,4BAAY,CAAoB,mBAAiB,CAAC,WAAW,EAAE,mBAAiB,CAAC,eAAe,CAAC,CAAA;AAHlH,iBAAiB;IAD7B,IAAA,sBAAU,GAAE;;GACA,iBAAiB,CAgB7B;AAhBY,8CAAiB"}

package/dist/apis/codiac-relay/gen/client.d.ts

@@ -0,0 +1,244 @@
+import { IRepoOptions, IBetterLogger } from "@codiac.io/codiac-common";
+import { Result, ListResult, BatchResult, SingleResult, PatchSpecForOne, PatchSpecForMany, IdSpecFor } from "@codiac.io/codiac-common/contracts";
+import { ApiClientBase } from "../common/api-client-base";
+import { ApiUserCreds } from "../common/api-user-creds";
+import { RelayClientConfig } from "./client-config";
+import { ApiAuthMethodsLegacy } from "../common/security/api-auth-methods-legacy";
+export interface IThrowingRepoOptions extends IRepoOptions {
+    throwNotFound?: boolean;
+}
+export declare class RelayClient extends ApiClientBase {
+    static bootstrap(logger?: IBetterLogger): void;
+    /** Version of the remote api from which this client was generated */
+    static apiVersion: string;
+    static DEFAULT_API_URL: string;
+    /** Hardcoded to match the current setting on the server.
+     * TODO: Get this from a config that is copied from the server proiject to the client project on build.
+     */
+    /** This factory method is just for convenience and hasty backward compatibility with consumers not using ioc. */
+    static create(logger: IBetterLogger, apiRootUrl?: string, authToken?: string): RelayClient;
+    /** Local interface for the remote api.
+     * @param settings (optional) configuration (ie: apiRootUrl) to use for the client.  If not provided settings will be loaded from the config file on the local machine.
+     *
+     */
+    constructor(logger: IBetterLogger, settings?: RelayClientConfig, credentials?: ApiUserCreds);
+    protected GetDefaultRootUrl(): string;
+    AuthLegacy: ApiAuthMethodsLegacy;
+    Auth: AuthOperations;
+    Call: OtherOperations;
+    EntityAcl: EntityAclCruds;
+    AuthRole: AuthRoleCruds;
+}
+import { EntityAcl, EntityAclCriteria, AuthRole, AuthRoleCriteria } from "../contracts";
+declare class AuthOperations {
+    private core;
+    protected logger: IBetterLogger;
+    constructor(core: ApiClientBase, logger: IBetterLogger);
+    EntityAclCreateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclList(request: EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<EntityAcl>>;
+    EntityAclUpdateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclPatchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclGet(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclPatch(request: PatchSpecForOne<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    RoleCreateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleList(request: AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<AuthRole>>;
+    RoleUpdateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RolePatchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleDeleteWhere(request: AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleGet(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleUpdate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RolePatch(request: PatchSpecForOne<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleDelete(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleCreate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    /** Determines whether the given token is expired.
+     * @param throwOnError throws any encountered errors, including token parsing errors.
+     */
+    isExpired(token: string, throwOnError?: boolean): boolean;
+    extractTokenExpiration(token: string): Date | undefined;
+}
+declare class EntityAclCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Saves each given input as a new EntityAcl. */
+    tryCreateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    createMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Retrieves all the existing EntityAcl that satisfy the given criteria. */
+    tryReadMany(request: EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<EntityAcl>>;
+    readMany(request: EntityAclCriteria, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Overwrites each existing EntityAcl. */
+    tryUpdateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    updateMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Performs the given operations on each existing EntityAcl that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    patchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Retrieves the single, uniquely identified EntityAcl. */
+    tryRead(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    read(request: IdSpecFor<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Overwrites the existing EntityAcl. */
+    tryUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    update(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Performs the given operations on the existing EntityAcl. */
+    tryPatch(request: PatchSpecForOne<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    patch(request: PatchSpecForOne<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Deletes the existing EntityAcl. */
+    tryDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    delete(request: IdSpecFor<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Saves the input as a new EntityAcl. */
+    tryCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    create(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+}
+declare class AuthRoleCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Saves each given input as a new AuthRole. */
+    tryCreateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    createMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Retrieves all the existing AuthRole that satisfy the given criteria. */
+    tryReadMany(request: AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<AuthRole>>;
+    readMany(request: AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Overwrites each existing AuthRole. */
+    tryUpdateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    updateMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Performs the given operations on each existing AuthRole that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    patchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Deletes each existing AuthRole that satisfies the given criteria. */
+    tryDeleteWhere(request: AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    deleteWhere(request: AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Retrieves the single, uniquely identified AuthRole. */
+    tryRead(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    read(request: IdSpecFor<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Overwrites the existing AuthRole. */
+    tryUpdate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    update(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Performs the given operations on the existing AuthRole. */
+    tryPatch(request: PatchSpecForOne<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    patch(request: PatchSpecForOne<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Deletes the existing AuthRole. */
+    tryDelete(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    delete(request: IdSpecFor<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Saves the input as a new AuthRole. */
+    tryCreate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    create(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
+}
+import { ActivateBusListenerRequest, AssetReplicaLogRequest, AssetStatusRequest, AssetStatus, FetchAssetVersionsRequest, GetAwsNodeTypesRequest, AwsNodeType, GetAwsRegionsRequest, AwsRegion, GetAwsUserRequest, AwsIdentity, GetAzureContainerRegistriesRequest, AzureAcr, GetAzureLocationsRequest, AzureLocation, GetAzureNodeTypesRequest, AzureNodeType, GetAzureResourceGroupsRequest, GetAzureSubscriptionsRequest, AzureUserSubscription, GetAzureVnetsRequest, AzureVNet, ClusterAccessGrantRequest, AccessGrant, ClusterConnectionRequest, GetClusterDefaultsRequest, ClusterDefaults, GetRenderedCabinetConfigRequest, ImportConfigRequest, LogintoCloudProviderRequest, ApiAuthToken, CspLoginAuthCodeCatcherRequest, CspLoginAuthCodeCatcherResponse, CspLoginInteractiveRequest, CspLoginInteractiveResponse, CspLogoutCatcherRequest, CspLogoutInteractiveRequest, CspLogoutInteractiveResponse, GetCloudProviderUserRequest, DeployedConfigCriteria, DeployedConfig, AssetReplicaContext, K8sContainerRef, ExecuteCabinetKillerRequest, Cabinet, ExecuteCreateCabinetRequest, ExecuteCabinetMakerResponse, CreateClusterRequest, CreateClusterResponse, ExecuteClusterIngressCreateRequest, ExecuteClusterIngressCreateResponse, ExecuteClusterIngressDeleteRequest, ExecuteClusterIngressDeleteResponse, ClusterTillerInstallRequest, ClusterTillerInstallResponse, DeleteClusterInstanceRequest, DeleteClusterInstanceResponse, ExecuteDeployConfigsForRequest, ExecuteDeployConfigsForResponse, ExecuteDeployIngressForAssetsRequest, ExecuteDeployIngressForAssetsResponse, DeployRequest, IPartialAsset, ExecuteDestroyAssetsRequest, ExecuteDestroyAssetsResponse, ExecuteDomainUpsertRequest, CabinetAssetList, GetFileStoresRequest, FileStoreDef, GenerateAssetFromKitRequest, Kit, GenerateKitRequest, RegistrySearchRequest, ImageRepository, GetAvailableK8sVersionsRequest, AvailableK8sVersion, GetKnownPortNumbersRequest, KnownPortNumberAssignment, PublishServiceRequest, PublishServiceResponse, ReadAssetLogsForCabinetRequest, ReadAssetLogsForCabinetResponse, ReadImageTagsRequest, ReadKeysFromStoreContactRequest, ReadKeysFromStoreContactResponse, ReadyStateRequest, ApiReadyState, GetRegistryProvidersRequest, GetRegistryTypeRequest, RegistryTypeInfo, ScaleAssetRequest, AssetResourcesSpec, GetAllSecretProvidersRequest, CloudProviderEnum, GetSecretStoresRequest, SecretStore, FileRequest, Buffer, ZombieRefreshRequest } from "../contracts";
+declare class OtherOperations {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Bring me a valid token and I'll register with the websocket svc bus and listen to messages. */
+    activateBusListener(request: ActivateBusListenerRequest, options?: IRepoOptions): Promise<Result>;
+    /** Retrieves connection specifications to connect to the log stream for a given asset replica (to be used as input for the 'request' function from the npm package: https://www.npmjs.com/package/request). */
+    getLogStreamSpecs(request: AssetReplicaLogRequest, options?: IRepoOptions): Promise<SingleResult<Object>>;
+    /** Provides an asset-level snapshot of the status of the instances and versions of the given asset. */
+    assetStatus(request: AssetStatusRequest, options?: IRepoOptions): Promise<BatchResult<AssetStatus>>;
+    /** Retrieves all versions for the given asset/image both from the image registry and the asset version history. */
+    FetchAssetVersions(request: FetchAssetVersionsRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Retrieves the list of vm specs available for use as Aws cluster nodes. */
+    getAwsNodeTypes(request: GetAwsNodeTypesRequest, options?: IRepoOptions): Promise<ListResult<AwsNodeType>>;
+    /** Retrieves the list of data center locations and their human-readable ids. */
+    getAwsRegions(request: GetAwsRegionsRequest, options?: IRepoOptions): Promise<ListResult<AwsRegion>>;
+    /** Retrieves the basic identity info for the given aws credentials or for this tenant user's locally stored AWS user credentials. */
+    getAwsUser(request: GetAwsUserRequest, options?: IRepoOptions): Promise<SingleResult<AwsIdentity>>;
+    /** Retrieves the list of Azure Container Registries (ACRs) under the given azure subscription. */
+    getAzureAcrs(request: GetAzureContainerRegistriesRequest, options?: IRepoOptions): Promise<ListResult<AzureAcr>>;
+    /** Retrieves the list of data center locations available for Azure clusters. */
+    getAzureLocations(request: GetAzureLocationsRequest, options?: IRepoOptions): Promise<ListResult<AzureLocation>>;
+    /** Retrieves the list of vm specs available for use as Azure cluster nodes. */
+    getAzureNodeTypes(request: GetAzureNodeTypesRequest, options?: IRepoOptions): Promise<ListResult<AzureNodeType>>;
+    /** Retrieves the list of azure resource groups under the given subscription for the given location. */
+    getAzureResourceGroups(request: GetAzureResourceGroupsRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Retrieves the list of azure subscriptions for the given azure user account. */
+    getAzureSubscriptions(request: GetAzureSubscriptionsRequest, options?: IRepoOptions): Promise<ListResult<AzureUserSubscription>>;
+    /** Retrieves the list of virutal networks that exist under the given subscription for the given location. */
+    getAzureVnets(request: GetAzureVnetsRequest, options?: IRepoOptions): Promise<ListResult<AzureVNet>>;
+    /** Enables the given user to access the given cluster via cloud provider security. */
+    grantClusterAccess(request: ClusterAccessGrantRequest, options?: IRepoOptions): Promise<BatchResult<AccessGrant>>;
+    /** Retrieves connection specifications to connect to the cluster in which the given cabinet resides (to be used with the KubeConfig.loadFromString() method from the npm package: https://www.npmjs.com/package/@kubernetes/client-node). */
+    getClusterConnectionSpecs(request: ClusterConnectionRequest, options?: IRepoOptions): Promise<SingleResult<string>>;
+    /** Retrieves the default values for cluster creation */
+    getClusterDefaults(request: GetClusterDefaultsRequest, options?: IRepoOptions): Promise<SingleResult<ClusterDefaults>>;
+    /** REtrieves the final configuration file contents for the given cabinet */
+    GetRenderedCabinetConfig(request: GetRenderedCabinetConfigRequest, options?: IRepoOptions): Promise<SingleResult<string>>;
+    /** Uploads the contents of a config file and converts it to ScopedSettings */
+    ImportConfig(request: ImportConfigRequest, options?: IRepoOptions): Promise<Result>;
+    /** Authenticates with the given cloud service provider using the given credentials or, if none provided, using the credentials cached for the given csp. */
+    csp_login(request: LogintoCloudProviderRequest, options?: IRepoOptions): Promise<SingleResult<ApiAuthToken>>;
+    /** Target for the OAuth 2.0 Authorization Code Flow redirect.  Receives the authorization code, converts it to a token and passes the token down to the calling application (via websocket backchannel specified in the message state). */
+    csp_login_auth_code_catcher(request: CspLoginAuthCodeCatcherRequest, options?: IRepoOptions): Promise<SingleResult<CspLoginAuthCodeCatcherResponse>>;
+    /** Invokes the OAuth 2.0 interactive login sequence for the given cloud service provider. */
+    csp_login_interactive(request: CspLoginInteractiveRequest, options?: IRepoOptions): Promise<SingleResult<CspLoginInteractiveResponse>>;
+    /** Target for the OAuth 2.0 sign-out redirect.  Purges any existing tokens for the given csp and notifies the calling application (via websocket backchannel specified in the message). */
+    csp_logout_catcher(request: CspLogoutCatcherRequest, options?: IRepoOptions): Promise<SingleResult<CspLoginAuthCodeCatcherResponse>>;
+    /** Invokes the OAuth 2.0 interactive sign out sequence for the given cloud service provider (ensures that the browser and any other sso-related systems also get the sign-out message). */
+    csp_logout_interactive(request: CspLogoutInteractiveRequest, options?: IRepoOptions): Promise<SingleResult<CspLogoutInteractiveResponse>>;
+    /** Returns the currently cached username for the given cloud service provider. */
+    get_current_user_for(request: GetCloudProviderUserRequest, options?: IRepoOptions): Promise<SingleResult<string>>;
+    /** Retrieves the actual string file contents of the ultimate scoped configs that were written to the cabinet (sourced directly from the k8s ConfigMaps). */
+    getDeployedConfigs(request: DeployedConfigCriteria, options?: IRepoOptions): Promise<ListResult<DeployedConfig>>;
+    /** Retrieves connection specifications to connect to the cluster in which the given cabinet resides (to be used with the KubeConfig.loadFromString() method from the npm package: https://www.npmjs.com/package/@kubernetes/client-node), AND the names of the requested k8s entities. */
+    getExecConnectionSpec(request: AssetReplicaContext, options?: IRepoOptions): Promise<SingleResult<K8sContainerRef>>;
+    /** (generated operationId) */
+    postExecuteCabinetKiller(request: ExecuteCabinetKillerRequest, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
+    /** (generated operationId) */
+    postExecuteCabinetMaker(request: ExecuteCreateCabinetRequest, options?: IRepoOptions): Promise<ExecuteCabinetMakerResponse>;
+    /** (generated operationId) */
+    postExecuteClusterCreate(request: CreateClusterRequest, options?: IRepoOptions): Promise<CreateClusterResponse>;
+    /** (generated operationId) */
+    postExecuteClusterIngressCreate(request: ExecuteClusterIngressCreateRequest, options?: IRepoOptions): Promise<ExecuteClusterIngressCreateResponse>;
+    /** (generated operationId) */
+    postExecuteClusterIngressDelete(request: ExecuteClusterIngressDeleteRequest, options?: IRepoOptions): Promise<ExecuteClusterIngressDeleteResponse>;
+    /** (generated operationId) */
+    postExecuteClusterTillerInstall(request: ClusterTillerInstallRequest, options?: IRepoOptions): Promise<ClusterTillerInstallResponse>;
+    /** (generated operationId) */
+    postExecuteDeleteClusterInstance(request: DeleteClusterInstanceRequest, options?: IRepoOptions): Promise<DeleteClusterInstanceResponse>;
+    /** (generated operationId) */
+    postExecuteDeployConfigsFor(request: ExecuteDeployConfigsForRequest, options?: IRepoOptions): Promise<ExecuteDeployConfigsForResponse>;
+    /** (generated operationId) */
+    postExecuteDeployIngressFor(request: ExecuteDeployIngressForAssetsRequest, options?: IRepoOptions): Promise<ExecuteDeployIngressForAssetsResponse>;
+    /** (generated operationId) */
+    postExecuteDeployment(request: DeployRequest, options?: IRepoOptions): Promise<BatchResult<IPartialAsset>>;
+    /** (generated operationId) */
+    postExecuteDestroyAssets(request: ExecuteDestroyAssetsRequest, options?: IRepoOptions): Promise<ExecuteDestroyAssetsResponse>;
+    /** Creates or updates a host naming assignment strategy for a given domain. */
+    executeDomainUpsert(request: ExecuteDomainUpsertRequest, options?: IRepoOptions): Promise<Result>;
+    /** (generated operationId) */
+    postExecuteRecycleAssets(request: CabinetAssetList, options?: IRepoOptions): Promise<BatchResult<CabinetAssetList>>;
+    /** Retrieves list of references to captured file stores. */
+    GetFileStores(request: GetFileStoresRequest, options?: IRepoOptions): Promise<ListResult<FileStoreDef>>;
+    /** Generates a Kit object from an existing asset. (generated operationId) */
+    getGenerateAssetFromKit(request: GenerateAssetFromKitRequest, options?: IRepoOptions): Promise<SingleResult<Kit>>;
+    /** Generates a Kit object from an existing asset. (generated operationId) */
+    getGenerateKit(request: GenerateKitRequest, options?: IRepoOptions): Promise<SingleResult<Kit>>;
+    /** Returns the image repositories matching the search string in the given registry. */
+    searchRegistry(request: RegistrySearchRequest, options?: IRepoOptions): Promise<ListResult<ImageRepository>>;
+    /** Retrieves the list of k8s versions supported by the given cloud provider (and Codiac), for use in creating a cluster. */
+    getAvailableK8sVersions(request: GetAvailableK8sVersionsRequest, options?: IRepoOptions): Promise<ListResult<AvailableK8sVersion>>;
+    getKnownPortNumbers(request: GetKnownPortNumbersRequest, options?: IRepoOptions): Promise<ListResult<KnownPortNumberAssignment>>;
+    /** (generated operationId) */
+    postPublishService(request: PublishServiceRequest, options?: IRepoOptions): Promise<PublishServiceResponse>;
+    /** (generated operationId) */
+    postReadAssetLogs(request: ReadAssetLogsForCabinetRequest, options?: IRepoOptions): Promise<ReadAssetLogsForCabinetResponse>;
+    /** Retrieves the list of versions available for a given container image repository (generated operationId) */
+    getReadImageTags(request: ReadImageTagsRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** (generated operationId) */
+    postReadVaultStoreKeys(request: ReadKeysFromStoreContactRequest, options?: IRepoOptions): Promise<ReadKeysFromStoreContactResponse>;
+    readyState(request: ReadyStateRequest, options?: IRepoOptions): Promise<ApiReadyState>;
+    /** Returns the list of support cloud service providers with image registries. */
+    getRegistryProviders(request: GetRegistryProvidersRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Attempts to recognize the cloud Service provider from the given registry url. */
+    getRegistryType(request: GetRegistryTypeRequest, options?: IRepoOptions): Promise<SingleResult<RegistryTypeInfo>>;
+    /** Makes a cabinet-scoped change to the asset resource footprint, and applies it to the actual asset instances in the cluster. */
+    scaleAsset(request: ScaleAssetRequest, options?: IRepoOptions): Promise<SingleResult<AssetResourcesSpec>>;
+    /** Retrieves the list of cloud providers with secret stores support. */
+    GetAllSecretProviders(request: GetAllSecretProvidersRequest, options?: IRepoOptions): Promise<ListResult<CloudProviderEnum>>;
+    /** Retrieves a list of currently captured secret stores. */
+    GetSecretStores(request: GetSecretStoresRequest, options?: IRepoOptions): Promise<ListResult<SecretStore>>;
+    /** (generated operationId) */
+    getSwaggerUiPath(request: FileRequest, options?: IRepoOptions): Promise<Buffer>;
+    /** Triggers Zombie Mode metrics service instances to update to the latest schedule of zombie periods.  it does this by deploying the zombie schedule config maps and recycling the zombie metrics services. */
+    zombie_refresh(request: ZombieRefreshRequest, options?: IRepoOptions): Promise<Result>;
+}
+export {};