@codiac.io/codiac-cli 1.3.82 → 1.3.84

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

@@ -0,0 +1,883 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IRepoOptions, IThrowingRepoOptions } from "@codiac.io/codiac-common";
+import { UpdatePartialWhereRequest } from "@codiac.io/codiac-common/contracts";
+import { ListResult, BatchResult, SingleResult, PatchSpecForOne, PatchSpecForMany, IdSpecFor } from "@codiac.io/codiac-common/contracts";
+import * as Contracts from './contracts';
+export interface IRelayClient {
+    Auth: IAuthOperations;
+    Call: IOtherOperations;
+    AuthRole: IAuthRoleCruds;
+    Cabinet: ICabinetCruds;
+    ClusterDef: IClusterDefCruds;
+    DefaultChildAcl: IDefaultChildAclCruds;
+    DeployAttempt: IDeployAttemptCruds;
+    Deployment: IDeploymentCruds;
+    EnterpriseRunState: IEnterpriseRunStateCruds;
+    EntityAcl: IEntityAclCruds;
+    Environment: IEnvironmentCruds;
+    FileStoreDef: IFileStoreDefCruds;
+    ScopedHostNameConfig: IScopedHostNameConfigCruds;
+    ScopedSetting: IScopedSettingCruds;
+    SetupJournal: ISetupJournalCruds;
+    ZombiePeriod: IZombiePeriodCruds;
+}
+export interface IAuthOperations {
+    RoleCreate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleCreateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleDelete(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleDeleteWhere(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleGet(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleList(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.AuthRole>>;
+    RolePatch(request: PatchSpecForOne<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RolePatchWhere(request: PatchSpecForMany<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleUpdate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleUpdateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleUpdatePartial(request: Partial<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.AuthRole>>>;
+    RoleUpdatePartialMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.AuthRole>>>;
+    RoleUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleUpsert(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleUpsertMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    DefaultChildAclCreate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclCreateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclDelete(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclGet(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclList(request: Contracts.DefaultChildAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclPatch(request: PatchSpecForOne<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclPatchWhere(request: PatchSpecForMany<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpdate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpdateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpdatePartial(request: Partial<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DefaultChildAcl>>>;
+    DefaultChildAclUpdatePartialMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DefaultChildAcl>>>;
+    DefaultChildAclUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpsert(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpsertMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    EntityAclCreate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclCreateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclDelete(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclDeleteWhere(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclGet(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclList(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EntityAcl>>;
+    EntityAclPatch(request: PatchSpecForOne<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclPatchWhere(request: PatchSpecForMany<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclUpdate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclUpdateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclUpdatePartial(request: Partial<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EntityAcl>>>;
+    EntityAclUpdatePartialMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EntityAcl>>>;
+    EntityAclUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclUpsert(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclUpsertMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    /** 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;
+}
+export interface IAuthRoleCruds {
+    /** Deletes each existing AuthRole that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    deleteWhere(request: Contracts.AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Retrieves all the existing AuthRole that satisfy the given criteria. */
+    tryReadMany(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.AuthRole>>;
+    readMany(request: Contracts.AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Performs the given operations on each existing AuthRole that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    patchWhere(request: PatchSpecForMany<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Saves each given input as a new AuthRole. */
+    tryCreateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    createMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Overwrites each existing AuthRole. */
+    tryUpdateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    updateMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Deletes the existing AuthRole. */
+    tryDelete(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    delete(request: IdSpecFor<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Retrieves the single, uniquely identified AuthRole. */
+    tryRead(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    read(request: IdSpecFor<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Performs the given operations on the existing AuthRole. */
+    tryPatch(request: PatchSpecForOne<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    patch(request: PatchSpecForOne<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Overwrites the existing AuthRole. */
+    tryUpdate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    update(request: Contracts.AuthRole, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Overwrites the given properties of the existing AuthRole. */
+    tryUpdatePartial(request: Partial<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.AuthRole>>>;
+    updatePartial(request: Partial<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.AuthRole>>;
+    /** Saves the input as a new AuthRole. */
+    tryCreate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    create(request: Contracts.AuthRole, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Overwrites the given properties for each existing AuthRole. */
+    tryUpdatePartialMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.AuthRole>>>;
+    updatePartialMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.AuthRole>[]>;
+    /** Performs the given operation on each existing AuthRole that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Saves the input as a new AuthRole, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    upsert(request: Contracts.AuthRole, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Saves each given input as a new AuthRole, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    upsertMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+}
+export interface ICabinetCruds {
+    /** Deletes each existing Cabinet that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.CabinetCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    deleteWhere(request: Contracts.CabinetCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Retrieves all the existing Cabinet that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CabinetCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Cabinet>>;
+    readMany(request: Contracts.CabinetCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Performs the given operations on each existing Cabinet that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Saves each given input as a new Cabinet. */
+    tryCreateMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    createMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Overwrites each existing Cabinet. */
+    tryUpdateMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    updateMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Deletes the existing Cabinet. */
+    tryDelete(request: IdSpecFor<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    delete(request: IdSpecFor<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Retrieves the single, uniquely identified Cabinet. */
+    tryRead(request: IdSpecFor<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    read(request: IdSpecFor<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Performs the given operations on the existing Cabinet. */
+    tryPatch(request: PatchSpecForOne<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    patch(request: PatchSpecForOne<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Overwrites the existing Cabinet. */
+    tryUpdate(request: Contracts.Cabinet, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    update(request: Contracts.Cabinet, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Overwrites the given properties of the existing Cabinet. */
+    tryUpdatePartial(request: Partial<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Cabinet>>>;
+    updatePartial(request: Partial<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Cabinet>>;
+    /** Saves the input as a new Cabinet. */
+    tryCreate(request: Contracts.Cabinet, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    create(request: Contracts.Cabinet, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Overwrites the given properties for each existing Cabinet. */
+    tryUpdatePartialMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Cabinet>>>;
+    updatePartialMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Cabinet>[]>;
+    /** Performs the given operation on each existing Cabinet that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Saves the input as a new Cabinet, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.Cabinet, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    upsert(request: Contracts.Cabinet, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Saves each given input as a new Cabinet, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    upsertMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+}
+export interface IClusterDefCruds {
+    /** Deletes each existing ClusterDef that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ClusterDefCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    deleteWhere(request: Contracts.ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Retrieves all the existing ClusterDef that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ClusterDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ClusterDef>>;
+    readMany(request: Contracts.ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Performs the given operations on each existing ClusterDef that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Saves each given input as a new ClusterDef. */
+    tryCreateMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    createMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Overwrites each existing ClusterDef. */
+    tryUpdateMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    updateMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Deletes the existing ClusterDef. */
+    tryDelete(request: IdSpecFor<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    delete(request: IdSpecFor<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Retrieves the single, uniquely identified ClusterDef. */
+    tryRead(request: IdSpecFor<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    read(request: IdSpecFor<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Performs the given operations on the existing ClusterDef. */
+    tryPatch(request: PatchSpecForOne<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    patch(request: PatchSpecForOne<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Overwrites the existing ClusterDef. */
+    tryUpdate(request: Contracts.ClusterDef, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    update(request: Contracts.ClusterDef, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Overwrites the given properties of the existing ClusterDef. */
+    tryUpdatePartial(request: Partial<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ClusterDef>>>;
+    updatePartial(request: Partial<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ClusterDef>>;
+    /** Saves the input as a new ClusterDef. */
+    tryCreate(request: Contracts.ClusterDef, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    create(request: Contracts.ClusterDef, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Overwrites the given properties for each existing ClusterDef. */
+    tryUpdatePartialMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ClusterDef>>>;
+    updatePartialMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ClusterDef>[]>;
+    /** Performs the given operation on each existing ClusterDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Saves the input as a new ClusterDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.ClusterDef, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    upsert(request: Contracts.ClusterDef, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Saves each given input as a new ClusterDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    upsertMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+}
+export interface IDefaultChildAclCruds {
+    /** Retrieves all the existing DefaultChildAcl that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DefaultChildAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DefaultChildAcl>>;
+    readMany(request: Contracts.DefaultChildAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Performs the given operations on each existing DefaultChildAcl that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    patchWhere(request: PatchSpecForMany<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Saves each given input as a new DefaultChildAcl. */
+    tryCreateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    createMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Overwrites each existing DefaultChildAcl. */
+    tryUpdateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    updateMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Deletes the existing DefaultChildAcl. */
+    tryDelete(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    delete(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Retrieves the single, uniquely identified DefaultChildAcl. */
+    tryRead(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    read(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Performs the given operations on the existing DefaultChildAcl. */
+    tryPatch(request: PatchSpecForOne<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    patch(request: PatchSpecForOne<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Overwrites the existing DefaultChildAcl. */
+    tryUpdate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    update(request: Contracts.DefaultChildAcl, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Overwrites the given properties of the existing DefaultChildAcl. */
+    tryUpdatePartial(request: Partial<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DefaultChildAcl>>>;
+    updatePartial(request: Partial<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DefaultChildAcl>>;
+    /** Saves the input as a new DefaultChildAcl. */
+    tryCreate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    create(request: Contracts.DefaultChildAcl, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Overwrites the given properties for each existing DefaultChildAcl. */
+    tryUpdatePartialMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DefaultChildAcl>>>;
+    updatePartialMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DefaultChildAcl>[]>;
+    /** Performs the given operation on each existing DefaultChildAcl that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Saves the input as a new DefaultChildAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    upsert(request: Contracts.DefaultChildAcl, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Saves each given input as a new DefaultChildAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    upsertMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+}
+export interface IDeployAttemptCruds {
+    /** Deletes each existing DeployAttempt that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DeployAttemptCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    deleteWhere(request: Contracts.DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Retrieves all the existing DeployAttempt that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DeployAttemptCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DeployAttempt>>;
+    readMany(request: Contracts.DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Performs the given operations on each existing DeployAttempt that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    patchWhere(request: PatchSpecForMany<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Saves each given input as a new DeployAttempt. */
+    tryCreateMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    createMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Overwrites each existing DeployAttempt. */
+    tryUpdateMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    updateMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Deletes the existing DeployAttempt. */
+    tryDelete(request: IdSpecFor<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    delete(request: IdSpecFor<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Retrieves the single, uniquely identified DeployAttempt. */
+    tryRead(request: IdSpecFor<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    read(request: IdSpecFor<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Performs the given operations on the existing DeployAttempt. */
+    tryPatch(request: PatchSpecForOne<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    patch(request: PatchSpecForOne<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Overwrites the existing DeployAttempt. */
+    tryUpdate(request: Contracts.DeployAttempt, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    update(request: Contracts.DeployAttempt, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Overwrites the given properties of the existing DeployAttempt. */
+    tryUpdatePartial(request: Partial<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DeployAttempt>>>;
+    updatePartial(request: Partial<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeployAttempt>>;
+    /** Saves the input as a new DeployAttempt. */
+    tryCreate(request: Contracts.DeployAttempt, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    create(request: Contracts.DeployAttempt, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Overwrites the given properties for each existing DeployAttempt. */
+    tryUpdatePartialMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DeployAttempt>>>;
+    updatePartialMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeployAttempt>[]>;
+    /** Performs the given operation on each existing DeployAttempt that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Saves the input as a new DeployAttempt, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.DeployAttempt, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    upsert(request: Contracts.DeployAttempt, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Saves each given input as a new DeployAttempt, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    upsertMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+}
+export interface IDeploymentCruds {
+    /** Deletes each existing Deployment that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DeploymentCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    deleteWhere(request: Contracts.DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Retrieves all the existing Deployment that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DeploymentCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Deployment>>;
+    readMany(request: Contracts.DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Performs the given operations on each existing Deployment that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Saves each given input as a new Deployment. */
+    tryCreateMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    createMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Overwrites each existing Deployment. */
+    tryUpdateMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    updateMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Deletes the existing Deployment. */
+    tryDelete(request: IdSpecFor<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    delete(request: IdSpecFor<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Retrieves the single, uniquely identified Deployment. */
+    tryRead(request: IdSpecFor<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    read(request: IdSpecFor<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Performs the given operations on the existing Deployment. */
+    tryPatch(request: PatchSpecForOne<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    patch(request: PatchSpecForOne<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Overwrites the existing Deployment. */
+    tryUpdate(request: Contracts.Deployment, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    update(request: Contracts.Deployment, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Overwrites the given properties of the existing Deployment. */
+    tryUpdatePartial(request: Partial<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Deployment>>>;
+    updatePartial(request: Partial<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Deployment>>;
+    /** Saves the input as a new Deployment. */
+    tryCreate(request: Contracts.Deployment, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    create(request: Contracts.Deployment, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Overwrites the given properties for each existing Deployment. */
+    tryUpdatePartialMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Deployment>>>;
+    updatePartialMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Deployment>[]>;
+    /** Performs the given operation on each existing Deployment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Saves the input as a new Deployment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.Deployment, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    upsert(request: Contracts.Deployment, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Saves each given input as a new Deployment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    upsertMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+}
+export interface IEnterpriseRunStateCruds {
+    /** Deletes each existing EnterpriseRunState that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    deleteWhere(request: Contracts.EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Retrieves all the existing EnterpriseRunState that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EnterpriseRunState>>;
+    readMany(request: Contracts.EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Performs the given operations on each existing EnterpriseRunState that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    patchWhere(request: PatchSpecForMany<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Saves each given input as a new EnterpriseRunState. */
+    tryCreateMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    createMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Overwrites each existing EnterpriseRunState. */
+    tryUpdateMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    updateMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Deletes the existing EnterpriseRunState. */
+    tryDelete(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    delete(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Retrieves the single, uniquely identified EnterpriseRunState. */
+    tryRead(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    read(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Performs the given operations on the existing EnterpriseRunState. */
+    tryPatch(request: PatchSpecForOne<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    patch(request: PatchSpecForOne<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Overwrites the existing EnterpriseRunState. */
+    tryUpdate(request: Contracts.EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    update(request: Contracts.EnterpriseRunState, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Overwrites the given properties of the existing EnterpriseRunState. */
+    tryUpdatePartial(request: Partial<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EnterpriseRunState>>>;
+    updatePartial(request: Partial<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EnterpriseRunState>>;
+    /** Saves the input as a new EnterpriseRunState. */
+    tryCreate(request: Contracts.EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    create(request: Contracts.EnterpriseRunState, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Overwrites the given properties for each existing EnterpriseRunState. */
+    tryUpdatePartialMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EnterpriseRunState>>>;
+    updatePartialMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EnterpriseRunState>[]>;
+    /** Performs the given operation on each existing EnterpriseRunState that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Saves the input as a new EnterpriseRunState, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    upsert(request: Contracts.EnterpriseRunState, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Saves each given input as a new EnterpriseRunState, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    upsertMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+}
+export interface IEntityAclCruds {
+    /** Deletes each existing EntityAcl that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    deleteWhere(request: Contracts.EntityAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Retrieves all the existing EntityAcl that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EntityAcl>>;
+    readMany(request: Contracts.EntityAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Performs the given operations on each existing EntityAcl that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    patchWhere(request: PatchSpecForMany<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Saves each given input as a new EntityAcl. */
+    tryCreateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    createMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Overwrites each existing EntityAcl. */
+    tryUpdateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    updateMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Deletes the existing EntityAcl. */
+    tryDelete(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    delete(request: IdSpecFor<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Retrieves the single, uniquely identified EntityAcl. */
+    tryRead(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    read(request: IdSpecFor<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Performs the given operations on the existing EntityAcl. */
+    tryPatch(request: PatchSpecForOne<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    patch(request: PatchSpecForOne<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Overwrites the existing EntityAcl. */
+    tryUpdate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    update(request: Contracts.EntityAcl, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Overwrites the given properties of the existing EntityAcl. */
+    tryUpdatePartial(request: Partial<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EntityAcl>>>;
+    updatePartial(request: Partial<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EntityAcl>>;
+    /** Saves the input as a new EntityAcl. */
+    tryCreate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    create(request: Contracts.EntityAcl, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Overwrites the given properties for each existing EntityAcl. */
+    tryUpdatePartialMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EntityAcl>>>;
+    updatePartialMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EntityAcl>[]>;
+    /** Performs the given operation on each existing EntityAcl that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Saves the input as a new EntityAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    upsert(request: Contracts.EntityAcl, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Saves each given input as a new EntityAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    upsertMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+}
+export interface IEnvironmentCruds {
+    /** Deletes each existing Environment that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EnvironmentCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    deleteWhere(request: Contracts.EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Retrieves all the existing Environment that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EnvironmentCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Environment>>;
+    readMany(request: Contracts.EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Performs the given operations on each existing Environment that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Saves each given input as a new Environment. */
+    tryCreateMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    createMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Overwrites each existing Environment. */
+    tryUpdateMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    updateMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Deletes the existing Environment. */
+    tryDelete(request: IdSpecFor<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    delete(request: IdSpecFor<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Retrieves the single, uniquely identified Environment. */
+    tryRead(request: IdSpecFor<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    read(request: IdSpecFor<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Performs the given operations on the existing Environment. */
+    tryPatch(request: PatchSpecForOne<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    patch(request: PatchSpecForOne<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Overwrites the existing Environment. */
+    tryUpdate(request: Contracts.Environment, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    update(request: Contracts.Environment, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Overwrites the given properties of the existing Environment. */
+    tryUpdatePartial(request: Partial<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Environment>>>;
+    updatePartial(request: Partial<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Environment>>;
+    /** Saves the input as a new Environment. */
+    tryCreate(request: Contracts.Environment, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    create(request: Contracts.Environment, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Overwrites the given properties for each existing Environment. */
+    tryUpdatePartialMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Environment>>>;
+    updatePartialMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Environment>[]>;
+    /** Performs the given operation on each existing Environment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Saves the input as a new Environment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.Environment, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    upsert(request: Contracts.Environment, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Saves each given input as a new Environment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    upsertMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+}
+export interface IFileStoreDefCruds {
+    /** Deletes each existing FileStoreDef that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.FileStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    deleteWhere(request: Contracts.FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Retrieves all the existing FileStoreDef that satisfy the given criteria. */
+    tryReadMany(request: Contracts.FileStoreDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.FileStoreDef>>;
+    readMany(request: Contracts.FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Performs the given operations on each existing FileStoreDef that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    patchWhere(request: PatchSpecForMany<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Saves each given input as a new FileStoreDef. */
+    tryCreateMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    createMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Overwrites each existing FileStoreDef. */
+    tryUpdateMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    updateMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Deletes the existing FileStoreDef. */
+    tryDelete(request: IdSpecFor<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    delete(request: IdSpecFor<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Retrieves the single, uniquely identified FileStoreDef. */
+    tryRead(request: IdSpecFor<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    read(request: IdSpecFor<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Performs the given operations on the existing FileStoreDef. */
+    tryPatch(request: PatchSpecForOne<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    patch(request: PatchSpecForOne<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Overwrites the existing FileStoreDef. */
+    tryUpdate(request: Contracts.FileStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    update(request: Contracts.FileStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Overwrites the given properties of the existing FileStoreDef. */
+    tryUpdatePartial(request: Partial<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.FileStoreDef>>>;
+    updatePartial(request: Partial<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.FileStoreDef>>;
+    /** Saves the input as a new FileStoreDef. */
+    tryCreate(request: Contracts.FileStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    create(request: Contracts.FileStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Overwrites the given properties for each existing FileStoreDef. */
+    tryUpdatePartialMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.FileStoreDef>>>;
+    updatePartialMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.FileStoreDef>[]>;
+    /** Performs the given operation on each existing FileStoreDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Saves the input as a new FileStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.FileStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    upsert(request: Contracts.FileStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Saves each given input as a new FileStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    upsertMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+}
+export interface IScopedHostNameConfigCruds {
+    /** Deletes each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    deleteWhere(request: Contracts.ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Retrieves all the existing ScopedHostNameConfig that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ScopedHostNameConfig>>;
+    readMany(request: Contracts.ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Performs the given operations on each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Saves each given input as a new ScopedHostNameConfig. */
+    tryCreateMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    createMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Overwrites each existing ScopedHostNameConfig. */
+    tryUpdateMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    updateMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Deletes the existing ScopedHostNameConfig. */
+    tryDelete(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    delete(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Retrieves the single, uniquely identified ScopedHostNameConfig. */
+    tryRead(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    read(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Performs the given operations on the existing ScopedHostNameConfig. */
+    tryPatch(request: PatchSpecForOne<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    patch(request: PatchSpecForOne<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Overwrites the existing ScopedHostNameConfig. */
+    tryUpdate(request: Contracts.ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    update(request: Contracts.ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Overwrites the given properties of the existing ScopedHostNameConfig. */
+    tryUpdatePartial(request: Partial<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ScopedHostNameConfig>>>;
+    updatePartial(request: Partial<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedHostNameConfig>>;
+    /** Saves the input as a new ScopedHostNameConfig. */
+    tryCreate(request: Contracts.ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    create(request: Contracts.ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Overwrites the given properties for each existing ScopedHostNameConfig. */
+    tryUpdatePartialMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ScopedHostNameConfig>>>;
+    updatePartialMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedHostNameConfig>[]>;
+    /** Performs the given operation on each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Saves the input as a new ScopedHostNameConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    upsert(request: Contracts.ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Saves each given input as a new ScopedHostNameConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    upsertMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+}
+export interface IScopedSettingCruds {
+    /** Deletes each existing ScopedSetting that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ScopedSettingCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    deleteWhere(request: Contracts.ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Retrieves all the existing ScopedSetting that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ScopedSettingCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ScopedSetting>>;
+    readMany(request: Contracts.ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Performs the given operations on each existing ScopedSetting that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Saves each given input as a new ScopedSetting. */
+    tryCreateMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    createMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Overwrites each existing ScopedSetting. */
+    tryUpdateMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    updateMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Deletes the existing ScopedSetting. */
+    tryDelete(request: IdSpecFor<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    delete(request: IdSpecFor<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Retrieves the single, uniquely identified ScopedSetting. */
+    tryRead(request: IdSpecFor<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    read(request: IdSpecFor<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Performs the given operations on the existing ScopedSetting. */
+    tryPatch(request: PatchSpecForOne<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    patch(request: PatchSpecForOne<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Overwrites the existing ScopedSetting. */
+    tryUpdate(request: Contracts.ScopedSetting, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    update(request: Contracts.ScopedSetting, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Overwrites the given properties of the existing ScopedSetting. */
+    tryUpdatePartial(request: Partial<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ScopedSetting>>>;
+    updatePartial(request: Partial<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedSetting>>;
+    /** Saves the input as a new ScopedSetting. */
+    tryCreate(request: Contracts.ScopedSetting, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    create(request: Contracts.ScopedSetting, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Overwrites the given properties for each existing ScopedSetting. */
+    tryUpdatePartialMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ScopedSetting>>>;
+    updatePartialMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedSetting>[]>;
+    /** Performs the given operation on each existing ScopedSetting that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Saves the input as a new ScopedSetting, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.ScopedSetting, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    upsert(request: Contracts.ScopedSetting, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Saves each given input as a new ScopedSetting, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    upsertMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+}
+export interface ISetupJournalCruds {
+    /** Deletes each existing SetupJournal that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.SetupJournalCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    deleteWhere(request: Contracts.SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Retrieves all the existing SetupJournal that satisfy the given criteria. */
+    tryReadMany(request: Contracts.SetupJournalCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.SetupJournal>>;
+    readMany(request: Contracts.SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Performs the given operations on each existing SetupJournal that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    patchWhere(request: PatchSpecForMany<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Saves each given input as a new SetupJournal. */
+    tryCreateMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    createMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Overwrites each existing SetupJournal. */
+    tryUpdateMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    updateMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Deletes the existing SetupJournal. */
+    tryDelete(request: IdSpecFor<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    delete(request: IdSpecFor<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Retrieves the single, uniquely identified SetupJournal. */
+    tryRead(request: IdSpecFor<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    read(request: IdSpecFor<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Performs the given operations on the existing SetupJournal. */
+    tryPatch(request: PatchSpecForOne<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    patch(request: PatchSpecForOne<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Overwrites the existing SetupJournal. */
+    tryUpdate(request: Contracts.SetupJournal, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    update(request: Contracts.SetupJournal, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Overwrites the given properties of the existing SetupJournal. */
+    tryUpdatePartial(request: Partial<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.SetupJournal>>>;
+    updatePartial(request: Partial<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.SetupJournal>>;
+    /** Saves the input as a new SetupJournal. */
+    tryCreate(request: Contracts.SetupJournal, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    create(request: Contracts.SetupJournal, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Overwrites the given properties for each existing SetupJournal. */
+    tryUpdatePartialMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.SetupJournal>>>;
+    updatePartialMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.SetupJournal>[]>;
+    /** Performs the given operation on each existing SetupJournal that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Saves the input as a new SetupJournal, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.SetupJournal, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    upsert(request: Contracts.SetupJournal, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Saves each given input as a new SetupJournal, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    upsertMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+}
+export interface IZombiePeriodCruds {
+    /** Deletes each existing ZombiePeriod that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ZombiePeriodCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    deleteWhere(request: Contracts.ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Retrieves all the existing ZombiePeriod that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ZombiePeriodCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ZombiePeriod>>;
+    readMany(request: Contracts.ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Performs the given operations on each existing ZombiePeriod that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Saves each given input as a new ZombiePeriod. */
+    tryCreateMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    createMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Overwrites each existing ZombiePeriod. */
+    tryUpdateMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    updateMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Deletes the existing ZombiePeriod. */
+    tryDelete(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    delete(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Retrieves the single, uniquely identified ZombiePeriod. */
+    tryRead(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    read(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Performs the given operations on the existing ZombiePeriod. */
+    tryPatch(request: PatchSpecForOne<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    patch(request: PatchSpecForOne<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Overwrites the existing ZombiePeriod. */
+    tryUpdate(request: Contracts.ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    update(request: Contracts.ZombiePeriod, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Overwrites the given properties of the existing ZombiePeriod. */
+    tryUpdatePartial(request: Partial<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ZombiePeriod>>>;
+    updatePartial(request: Partial<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ZombiePeriod>>;
+    /** Saves the input as a new ZombiePeriod. */
+    tryCreate(request: Contracts.ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    create(request: Contracts.ZombiePeriod, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Overwrites the given properties for each existing ZombiePeriod. */
+    tryUpdatePartialMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ZombiePeriod>>>;
+    updatePartialMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ZombiePeriod>[]>;
+    /** Performs the given operation on each existing ZombiePeriod that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Saves the input as a new ZombiePeriod, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Contracts.ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    upsert(request: Contracts.ZombiePeriod, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Saves each given input as a new ZombiePeriod, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    upsertMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+}
+export interface IOtherOperations {
+    /** Includes the given cluster within the given environment. */
+    EnvironmentClusterAttach(request: Contracts.ClusterAttachRequest, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Environment>>>;
+    /** Removes the linkage between the given environment and the given cluster. */
+    EnvironmentClusterDetach(request: Contracts.ClusterDetachRequest, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Environment>>>;
+    /** Retrieves all versions for the given asset/image both from the image registry and the asset version history. */
+    FetchAssetVersions(request: Contracts.FetchAssetVersionsRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Retrieves the list of cloud providers with secret stores support. */
+    GetAllSecretProviders(request: Contracts.GetAllSecretProvidersRequest, options?: IRepoOptions): Promise<ListResult<Contracts.CloudProviderEnum>>;
+    /** Retrieves lightly loaded cabinets (from RootMap) matching the given criteria. */
+    GetCabinets(request: Contracts.CabinetSelector, options?: IRepoOptions): Promise<ListResult<Contracts.CabinetClusterRoot>>;
+    /** Retrieves a list of kubernetes clusters that currently exist in a cloud subscription. */
+    GetExistingCspClusters(request: Contracts.GetExistingCspClustersRequest, options?: IRepoOptions): Promise<ListResult<Contracts.Cluster>>;
+    /** Retrieves list of references to captured file stores. */
+    GetFileStores(request: Contracts.GetFileStoresRequest, options?: IRepoOptions): Promise<ListResult<Contracts.FileStoreDef>>;
+    /** REtrieves the final configuration file contents for the given cabinet */
+    GetRenderedCabinetConfig(request: Contracts.GetRenderedCabinetConfigRequest, options?: IRepoOptions): Promise<SingleResult<string>>;
+    /** Retrieves a list of currently captured secret stores. */
+    GetSecretStores(request: Contracts.GetSecretStoresRequest, options?: IRepoOptions): Promise<ListResult<Contracts.SecretStore>>;
+    GetStorageAccountKeys(request: Contracts.GetStorageAccountKeysRequest, options?: IRepoOptions): Promise<ListResult<Contracts.StorageAccountKey>>;
+    /** Retrieves list of references to cloud file storage accounts. */
+    GetStorageAccounts(request: Contracts.GetStorageAccountRequest, options?: IRepoOptions): Promise<ListResult<Contracts.StorageAccount>>;
+    /** Uploads the contents of a config file and converts it to ScopedSettings */
+    ImportConfig(request: Contracts.ImportConfigRequest, options?: IRepoOptions): Promise<Contracts.Result>;
+    /** Bring me a valid token and I'll register with the websocket svc bus and listen to messages. */
+    activateBusListener(request: Contracts.ActivateBusListenerRequest, options?: IRepoOptions): Promise<Contracts.Result>;
+    /** Provides an asset-level snapshot of the status of the instances and versions of the given asset. */
+    assetStatus(request: Contracts.AssetStatusRequest, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetStatus>>;
+    /** Shows the cabinets to which the given asset is currently deployed and which version is where. */
+    assetWhere(request: Contracts.AssetWhereRequest, options?: IRepoOptions): Promise<ListResult<Contracts.CabinetAssetVersion>>;
+    /** Creates a new record in Codiac for a cluster that already physically exists in a cloud subscription. */
+    clusterCapture(request: Contracts.ExecuteClusterInitRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    clusterCreateAsync(request: Contracts.CreateClusterRequestAsync, options?: IRepoOptions): Promise<SingleResult<Contracts.CreateClusterAck>>;
+    clusterDeinit(request: Contracts.ExecuteClusterIngressDeleteRequest, options?: IRepoOptions): Promise<Contracts.ExecuteClusterIngressDeleteResponse>;
+    clusterInit(request: Contracts.ExecuteClusterInitRequestAsync, options?: IRepoOptions): Promise<Contracts.ExecuteClusterInitResponse>;
+    /** 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: Contracts.LogintoCloudProviderRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTokenAndUserMeta>>;
+    /** 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: Contracts.CspLoginAuthCodeCatcherRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.CspLoginAuthCodeCatcherResponse>>;
+    /** Invokes the OAuth 2.0 interactive login sequence for the given cloud service provider. */
+    csp_login_interactive(request: Contracts.CspLoginInteractiveRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.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: Contracts.CspLogoutCatcherRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.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: Contracts.CspLogoutInteractiveRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.CspLogoutInteractiveResponse>>;
+    /** Deletes a previously declared host naming strategy declaration for a given domain. */
+    domainDelete(request: Contracts.DomainDeleteRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    /** UN-deploys the given assets from the given cabinet. */
+    executeDestroyAssets(request: Contracts.UndeployAssetsRequest, options?: IRepoOptions): Promise<Contracts.Result>;
+    /** Creates or updates a host naming assignment strategy for a given domain. */
+    executeDomainUpsert(request: Contracts.ExecuteDomainUpsertRequest, options?: IRepoOptions): Promise<Contracts.Result>;
+    /** Provides any predefined structure (eg: setting names, meta, and types) for an asset config. */
+    get_asset_config_schema(request: Contracts.AssetConfigSchemaRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.Schema>>;
+    /** Retrieves the names of the available autoscaling metrics, for use when defining autoscaling on asset footprints. */
+    get_autoscaling_metrics(request: Contracts.GetAutoscalingMetricsRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.Schema>>;
+    /** Returns the currently cached username for the given cloud service provider. */
+    get_current_users_for(request: Contracts.GetCloudProviderUserRequest, options?: IRepoOptions): Promise<ListResult<Contracts.CspPrimaryCredsMeta>>;
+    /** Retrieves the list of k8s versions supported by the given cloud provider (and Codiac), for use in creating a cluster. */
+    getAvailableK8sVersions(request: Contracts.GetAvailableK8sVersionsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AvailableK8sVersion>>;
+    /** Retrieves the list of vm specs available for use as Aws cluster nodes. */
+    getAwsNodeTypes(request: Contracts.GetAwsNodeTypesRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AwsNodeType>>;
+    /** Retrieves the list of data center locations and their human-readable ids. */
+    getAwsRegions(request: Contracts.GetAwsRegionsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AwsRegion>>;
+    /** Retrieves the list of existing S3 buckets available in the given Aws account. */
+    getAwsS3Buckets(request: Contracts.GetAwsS3BucketsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AwsS3Bucket>>;
+    /** Retrieves the basic identity info for the given aws credentials or for this tenant user's locally stored AWS user credentials. */
+    getAwsUser(request: Contracts.GetAwsUserRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.AwsIdentity>>;
+    /** Retrieves the list of Azure Container Registries (ACRs) under the given azure subscription. */
+    getAzureAcrs(request: Contracts.GetAzureContainerRegistriesRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AzureAcr>>;
+    /** Retrieves the list of data center locations available for Azure clusters. */
+    getAzureLocations(request: Contracts.GetAzureLocationsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AzureLocation>>;
+    /** Retrieves the list of vm specs available for use as Azure cluster nodes. */
+    getAzureNodeTypes(request: Contracts.GetAzureNodeTypesRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AzureNodeType>>;
+    /** Retrieves the list of azure resource groups under the given subscription for the given location. */
+    getAzureResourceGroups(request: Contracts.GetAzureResourceGroupsRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Retrieves the list of azure subscriptions for the given azure user account. */
+    getAzureSubscriptions(request: Contracts.GetAzureSubscriptionsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AzureUserSubscription>>;
+    /** Retrieves the list of virutal networks that exist under the given subscription for the given location. */
+    getAzureVnets(request: Contracts.GetAzureVnetsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AzureVNet>>;
+    /** 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: Contracts.ClusterConnectionRequest, options?: IRepoOptions): Promise<SingleResult<string>>;
+    /** Retrieves the default values for cluster creation */
+    getClusterDefaults(request: Contracts.GetClusterDefaultsRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDefaults>>;
+    /** Retrieves the list of currently declared config files for the given enterprise asset. */
+    getConfigDefs(request: Contracts.ConfigDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ConfigDef>>;
+    getConfigDoc(request: Contracts.ConfigDocSpecForOne, options?: IRepoOptions): Promise<Contracts.ConfigDoc>;
+    /** 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: Contracts.DeployedConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DeployedConfig>>;
+    /** Retrieves a manifest of all versions and configs currently deployed within the given enterprise. */
+    getDeployedState(request: Contracts.EnterpriseStateRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseState>>;
+    /** 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: Contracts.AssetReplicaContext, options?: IRepoOptions): Promise<SingleResult<Contracts.K8sContainerRef>>;
+    /** Generates a Kit object from an existing asset. (generated operationId) */
+    getGenerateAssetFromKit(request: Contracts.GenerateAssetFromKitRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    /** Generates a Kit object from an existing asset. (generated operationId) */
+    getGenerateKit(request: Contracts.GenerateKitRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    /** Retrieves a list of all host naming strategies as applied to the map of enteprises, environments, and cabinets. */
+    getIngressMap(request: Contracts.IngressMapRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.IngressMap>>;
+    getKnownPortNumbers(request: Contracts.GetKnownPortNumbersRequest, options?: IRepoOptions): Promise<ListResult<Contracts.KnownPortNumberAssignment>>;
+    /** 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: Contracts.AssetReplicaLogRequest, options?: IRepoOptions): Promise<SingleResult<Object>>;
+    /** Retrieves the list of versions available for a given container image repository (generated operationId) */
+    getReadImageTags(request: Contracts.ReadImageTagsRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Returns the list of support cloud service providers with image registries. */
+    getRegistryProviders(request: Contracts.GetRegistryProvidersRequest, options?: IRepoOptions): Promise<ListResult<string>>;
+    /** Attempts to recognize the cloud Service provider from the given registry url. */
+    getRegistryType(request: Contracts.GetRegistryTypeRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.RegistryTypeInfo>>;
+    /** All the enterprises, assets, cabinets, environments, and clusters for the current tenant. That is, retrieves a semi-detailed list of all the primary entities of a tenant's software organization.  Originally designed for use in ingress routing. */
+    getRootMap(request: Contracts.RootMapCriteria, options?: IRepoOptions): Promise<SingleResult<Contracts.RootMap>>;
+    /** Assembles (via smashMerge) a single config doc for the given enterprise asset, scoped for the given cabinet. */
+    getScopedConfigs(request: Contracts.ScopedConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ScopedConfig>>;
+    /** (generated operationId) */
+    getSwaggerUiPath(request: Contracts.FileRequest, options?: IRepoOptions): Promise<Buffer>;
+    /** Enables the given user to access the given cluster via cloud provider security. */
+    grantClusterAccess(request: Contracts.ClusterAccessGrantRequest, options?: IRepoOptions): Promise<BatchResult<Contracts.AccessGrant>>;
+    /** Lightweight endpoint returning the last heartbeat as a UTC standard format date string (retrieves from ENV variable: HEARTBEAT_LAST). */
+    heartbeat(request: Object, options?: IRepoOptions): Promise<void>;
+    /** Lightweight endpoint returning the last heartbeat object as a JSON string (retrieves from ENV variable: HEARTBEAT_JSON). */
+    heartbeatJson(request: Object, options?: IRepoOptions): Promise<Contracts.HeartbeatRecord>;
+    /** (generated operationId) */
+    postExecuteCabinetKiller(request: Contracts.ExecuteCabinetKillerRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    /** (generated operationId) */
+    postExecuteCabinetMaker(request: Contracts.ExecuteCreateCabinetRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    /** (generated operationId) */
+    postExecuteDeleteClusterInstance(request: Contracts.DeleteClusterInstanceRequest, options?: IRepoOptions): Promise<Contracts.DeleteClusterInstanceResponse>;
+    /** (generated operationId) */
+    postExecuteDeployConfigsFor(request: Contracts.ExecuteDeployConfigsForRequest, options?: IRepoOptions): Promise<Contracts.ExecuteDeployConfigsForResponse>;
+    /** (generated operationId) */
+    postExecuteDeployIngressFor(request: Contracts.ExecuteDeployIngressForAssetsRequest, options?: IRepoOptions): Promise<Contracts.ExecuteDeployIngressForAssetsResponse>;
+    /** (generated operationId) */
+    postExecuteDeployment(request: Contracts.DeployRequest, options?: IRepoOptions): Promise<BatchResult<Contracts.IPartialAsset>>;
+    /** (generated operationId) */
+    postExecuteRecycleAssets(request: Contracts.CabinetAssetList, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetAssetList>>;
+    /** (generated operationId) */
+    postReadAssetLogs(request: Contracts.ReadAssetLogsForCabinetRequest, options?: IRepoOptions): Promise<Contracts.ReadAssetLogsForCabinetResponse>;
+    /** (generated operationId) */
+    postReadVaultStoreKeys(request: Contracts.ReadKeysFromStoreContactRequest, options?: IRepoOptions): Promise<Contracts.ReadKeysFromStoreContactResponse>;
+    /** Retrieves a status of cluster ip via nslookup in a given registered DNS. */
+    readDnsConnection(request: Contracts.DnsConnectionRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.DnsResponse>>;
+    readyState(request: Contracts.ReadyStateRequest, options?: IRepoOptions): Promise<Contracts.ApiReadyState>;
+    /** Retrieves a list of all host naming strategies as applied to the map of enteprises, environments, and cabinets. */
+    recaptureIngressIp(request: Contracts.IngressMapRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.IngressMap>>;
+    /** Makes a cabinet-scoped change to the asset resource footprint, and applies it to the actual asset instances in the cluster. */
+    scaleAsset(request: Contracts.ScaleAssetRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetResourcesSpec>>;
+    /** Returns the image repositories matching the search string in the given registry. */
+    searchRegistry(request: Contracts.RegistrySearchRequest, options?: IRepoOptions): Promise<ListResult<Contracts.ImageRepository>>;
+    /** Ensures that the specified cluster is running. */
+    startCluster(request: Contracts.ClusterStartRequestAsync, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterStartAck>>;
+    /** Ensures that the specified cluster is not running. */
+    stopCluster(request: Contracts.ClusterStopRequestAsync, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterStopAck>>;
+    /** 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: Contracts.ZombieRefreshRequest, options?: IRepoOptions): Promise<Contracts.Result>;
+}