@codiac.io/codiac-cli 1.3.120 → 1.3.122

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

@@ -0,0 +1,995 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { interfaces } from "inversify";
+import { Buffer } from "buffer";
+import { IRepoOptions, IBetterLogger } from "@codiac.io/codiac-common";
+import { ListResult, BatchResult, SingleResult, PatchSpecForOne, PatchSpecForMany, IdSpecFor } from "@codiac.io/codiac-common/contracts";
+import { TokenCreds } from "../common/token";
+import { RelayNatsClientConfig } from "./config";
+import { UpdatePartialWhereRequest, IThrowingRepoOptions } from "../common/types";
+import * as Contracts from './contracts';
+import * as Nats from "@nats-io/nats-core";
+import { IStackableNatsClient } from "../../codiac-api/i-client";
+import { TokenUtils } from "../common/token-utils";
+export type NatsClientOptions = {
+    requestTimeoutInMs: number;
+};
+export declare class RelayNatsClient implements /* ICodiacClient, */ /* IRelayClient, */ IStackableNatsClient {
+    logger: IBetterLogger;
+    private _settings;
+    private _tokenCredentials?;
+    static readonly DEFAULT_TOKEN_HEADER_PARAM = "authorization";
+    /** Version of the remote api from which this client was generated */
+    static apiVersion: string;
+    /** The name of the jwt claim in the codiac token that holds the nats credentials.  */
+    private static readonly CLAIM_FOR_GLOBAL_CLIENT_KEY;
+    static readonly DEFAULTS: RelayNatsClientConfig;
+    static bootstrap(ioc: interfaces.Container, settings?: Partial<RelayNatsClientConfig>): void;
+    /** This factory method is just for convenience and hasty backward compatibility with consumers not using ioc. */
+    static create(logger: IBetterLogger, configuration?: RelayNatsClientConfig, codiacJwt?: string | TokenCreds): RelayNatsClient;
+    private static _nc;
+    static get nc(): Nats.NatsConnection | undefined;
+    constructor(logger: IBetterLogger, _settings: RelayNatsClientConfig, _tokenCredentials?: TokenCreds | undefined);
+    TokenUtils: TokenUtils;
+    endpoints: {
+        [operationId: string]: string[];
+    };
+    registerEndpoints(endpoints: {
+        [op: string]: string[];
+    }): void;
+    supportsSubject(subject: string): boolean;
+    /** Throws if not found; */
+    opFor(subject: string): string;
+    isExpired(token: string, throwOnError?: boolean): boolean;
+    /** Sets the user context to impersonate in requests made to the api. */
+    setUserToken(token: string): void;
+    connect(): Promise<Nats.ServerInfo | undefined>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+    /** Disregards any instances and checks the underlying connection store
+     * for any connections that are currently not closed or draining. */
+    static areAnyConnected(): boolean;
+    /** Closes any unclosed connections in the underlying connection store (regardless of instances). */
+    static disconnectAll(): Promise<void>;
+    /** Declaration of what messaging protocol to connect with. */
+    private clientType;
+    get tokenCredentials(): TokenCreds | undefined;
+    set tokenCredentials(value: TokenCreds | undefined);
+    get settings(): RelayNatsClientConfig;
+    private getValues;
+    request<TRequest, TResponse>(subject: string, req?: TRequest, options?: IRepoOptions, clientOptions?: Partial<NatsClientOptions>): Promise<TResponse>;
+    private makeRequest;
+    Auth: AuthOperations;
+    Call: OtherOperations;
+    AuthRole: AuthRoleCruds;
+    Cabinet: CabinetCruds;
+    ClusterDef: ClusterDefCruds;
+    DefaultChildAcl: DefaultChildAclCruds;
+    DeployAttempt: DeployAttemptCruds;
+    Deployment: DeploymentCruds;
+    EnterpriseRunState: EnterpriseRunStateCruds;
+    EntityAcl: EntityAclCruds;
+    Environment: EnvironmentCruds;
+    FileStoreDef: FileStoreDefCruds;
+    ScopedHostNameConfig: ScopedHostNameConfigCruds;
+    ScopedSetting: ScopedSettingCruds;
+    SetupJournal: SetupJournalCruds;
+    ZombiePeriod: ZombiePeriodCruds;
+}
+declare class AuthOperations {
+    private core;
+    constructor(core: RelayNatsClient);
+    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;
+}
+declare class AuthRoleCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class CabinetCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class ClusterDefCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class DefaultChildAclCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class DeployAttemptCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class DeploymentCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class EnterpriseRunStateCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class EntityAclCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class EnvironmentCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class FileStoreDefCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class ScopedHostNameConfigCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class ScopedSettingCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class SetupJournalCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class ZombiePeriodCruds {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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[]>;
+}
+declare class OtherOperations {
+    private core;
+    constructor(core: RelayNatsClient);
+    private endpoints;
+    /** 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 all versions for the given asset/image both from the image registry and the asset version history. */
+    FetchAssetVersionsSearch(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>>;
+    /** Assembles (via smashMerge) the host naming strategy configuration for each applicable cabinet. Allows deeper filtering on domain names and types of host name strategies. */
+    GetCabinetHostNameConfig(request: Contracts.CabinetHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CabinetHostNameConfig>>;
+    /** 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.ClusterCaptureRequest, 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>>;
+    /** Ensures that the Codiac app itself is registered within the security model of the given cloud service provider (aws, azure, docker, etc) and granted appropriate access.  eg: in Azure, this endpoint registers Codiac as an App Registration in Entra, aka: Azure AD, whereas DockerHub does not require this at all).  One tenant profile needs to be created for a given cloud provider tenant account. */
+    csp_tenant_profile_getsert(request: Contracts.CspTenantProfileGetsertRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    /** 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 list of subnets in a given VPC. */
+    getAwsSubnets(request: Contracts.GetAwsSubnetsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AwsSubnet>>;
+    /** 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 VPCs in a given aws account. */
+    getAwsVpcs(request: Contracts.GetAwsVpcsRequest, options?: IRepoOptions): Promise<ListResult<Contracts.AwsVpc>>;
+    /** 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 all available enterprises, environments, cabinets, and clusters for the given tenant. */
+    getCabinetScopes(request: Contracts.CabinetScopesCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EnterpriseScope>>;
+    /** 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 enterprises, 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>>;
+    /** 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<SingleResult<Array<string>>>;
+    /** 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>;
+}
+export {};