/**
 * Azure Hdinsight API
 *
 * Generated from the Azure REST API specs.
 * DO NOT EDIT - regenerate with: bun run generate
 */
import * as Schema from "effect/Schema";
export declare const ApplicationsCreateInput: Schema.Struct<{}>;
export type ApplicationsCreateInput = typeof ApplicationsCreateInput.Type;
export declare const ApplicationsCreateOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type ApplicationsCreateOutput = typeof ApplicationsCreateOutput.Type;
/**
 * Creates applications for the HDInsight cluster.
 */
export declare const ApplicationsCreate: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ApplicationsDeleteInput: Schema.Struct<{}>;
export type ApplicationsDeleteInput = typeof ApplicationsDeleteInput.Type;
export declare const ApplicationsDeleteOutput: Schema.Void;
export type ApplicationsDeleteOutput = typeof ApplicationsDeleteOutput.Type;
/**
 * Deletes the specified application on the HDInsight cluster.
 */
export declare const ApplicationsDelete: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ApplicationsGetInput: Schema.Struct<{}>;
export type ApplicationsGetInput = typeof ApplicationsGetInput.Type;
export declare const ApplicationsGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type ApplicationsGetOutput = typeof ApplicationsGetOutput.Type;
/**
 * Gets properties of the specified application.
 */
export declare const ApplicationsGet: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ApplicationsGetAzureAsyncOperationStatusInput: Schema.Struct<{}>;
export type ApplicationsGetAzureAsyncOperationStatusInput = typeof ApplicationsGetAzureAsyncOperationStatusInput.Type;
export declare const ApplicationsGetAzureAsyncOperationStatusOutput: Schema.Struct<{
    readonly status: Schema.optional<Schema.Literals<readonly ["InProgress", "Succeeded", "Failed"]>>;
    readonly error: Schema.optional<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
    }>>;
}>;
export type ApplicationsGetAzureAsyncOperationStatusOutput = typeof ApplicationsGetAzureAsyncOperationStatusOutput.Type;
/**
 * Gets the async operation status.
 */
export declare const ApplicationsGetAzureAsyncOperationStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly error?: {
        readonly code?: string | undefined;
        readonly message?: string | undefined;
    } | undefined;
    readonly status?: "Failed" | "InProgress" | "Succeeded" | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ApplicationsListByClusterInput: Schema.Struct<{}>;
export type ApplicationsListByClusterInput = typeof ApplicationsListByClusterInput.Type;
export declare const ApplicationsListByClusterOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type ApplicationsListByClusterOutput = typeof ApplicationsListByClusterOutput.Type;
/**
 * Lists all of the applications for the HDInsight cluster.
 */
export declare const ApplicationsListByCluster: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersCreateInput: Schema.Struct<{}>;
export type ClustersCreateInput = typeof ClustersCreateInput.Type;
export declare const ClustersCreateOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type ClustersCreateOutput = typeof ClustersCreateOutput.Type;
/**
 * Creates a new HDInsight cluster with the specified parameters.
 */
export declare const ClustersCreate: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersDeleteInput: Schema.Struct<{}>;
export type ClustersDeleteInput = typeof ClustersDeleteInput.Type;
export declare const ClustersDeleteOutput: Schema.Void;
export type ClustersDeleteOutput = typeof ClustersDeleteOutput.Type;
/**
 * Deletes the specified HDInsight cluster.
 */
export declare const ClustersDelete: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ClustersExecuteScriptActionsInput: Schema.Struct<{
    readonly scriptActions: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly name: Schema.String;
        readonly uri: Schema.String;
        readonly parameters: Schema.optional<Schema.String>;
        readonly roles: Schema.$Array<Schema.String>;
        readonly applicationName: Schema.optional<Schema.String>;
    }>>>;
    readonly persistOnSuccess: Schema.Boolean;
}>;
export type ClustersExecuteScriptActionsInput = typeof ClustersExecuteScriptActionsInput.Type;
export declare const ClustersExecuteScriptActionsOutput: Schema.Void;
export type ClustersExecuteScriptActionsOutput = typeof ClustersExecuteScriptActionsOutput.Type;
/**
 * Executes script actions on the specified HDInsight cluster.
 * @param scriptActions - The list of run time script actions.
 * @param persistOnSuccess - Gets or sets if the scripts needs to be persisted.
 */
export declare const ClustersExecuteScriptActions: import("@distilled.cloud/core/client").OperationMethod<{
    readonly persistOnSuccess: boolean;
    readonly scriptActions?: readonly {
        readonly applicationName?: string | undefined;
        readonly name: string;
        readonly parameters?: string | undefined;
        readonly roles: readonly string[];
        readonly uri: string;
    }[] | undefined;
}, void, never, import("../credentials.ts").Credentials>;
export declare const ClustersGetInput: Schema.Struct<{}>;
export type ClustersGetInput = typeof ClustersGetInput.Type;
export declare const ClustersGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type ClustersGetOutput = typeof ClustersGetOutput.Type;
/**
 * Gets the specified cluster.
 */
export declare const ClustersGet: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersGetAzureAsyncOperationStatusInput: Schema.Struct<{}>;
export type ClustersGetAzureAsyncOperationStatusInput = typeof ClustersGetAzureAsyncOperationStatusInput.Type;
export declare const ClustersGetAzureAsyncOperationStatusOutput: Schema.Struct<{
    readonly status: Schema.optional<Schema.Literals<readonly ["InProgress", "Succeeded", "Failed"]>>;
    readonly error: Schema.optional<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
    }>>;
}>;
export type ClustersGetAzureAsyncOperationStatusOutput = typeof ClustersGetAzureAsyncOperationStatusOutput.Type;
/**
 * The the async operation status.
 */
export declare const ClustersGetAzureAsyncOperationStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly error?: {
        readonly code?: string | undefined;
        readonly message?: string | undefined;
    } | undefined;
    readonly status?: "Failed" | "InProgress" | "Succeeded" | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersGetGatewaySettingsInput: Schema.Struct<{}>;
export type ClustersGetGatewaySettingsInput = typeof ClustersGetGatewaySettingsInput.Type;
export declare const ClustersGetGatewaySettingsOutput: Schema.Struct<{
    readonly "restAuthCredential.isEnabled": Schema.optional<Schema.String>;
    readonly "restAuthCredential.username": Schema.optional<Schema.String>;
    readonly "restAuthCredential.password": Schema.optional<Schema.Schema<string | import("effect/Redacted").Redacted<string>>>;
}>;
export type ClustersGetGatewaySettingsOutput = typeof ClustersGetGatewaySettingsOutput.Type;
/**
 * Gets the gateway settings for the specified cluster.
 */
export declare const ClustersGetGatewaySettings: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly "restAuthCredential.isEnabled"?: string | undefined;
    readonly "restAuthCredential.password"?: string | import("effect/Redacted").Redacted<string> | undefined;
    readonly "restAuthCredential.username"?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersListInput: Schema.Struct<{}>;
export type ClustersListInput = typeof ClustersListInput.Type;
export declare const ClustersListOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type ClustersListOutput = typeof ClustersListOutput.Type;
/**
 * Lists all the HDInsight clusters under the subscription.
 */
export declare const ClustersList: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersListByResourceGroupInput: Schema.Struct<{}>;
export type ClustersListByResourceGroupInput = typeof ClustersListByResourceGroupInput.Type;
export declare const ClustersListByResourceGroupOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type ClustersListByResourceGroupOutput = typeof ClustersListByResourceGroupOutput.Type;
/**
 * Lists the HDInsight clusters in a resource group.
 */
export declare const ClustersListByResourceGroup: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersResizeInput: Schema.Struct<{
    readonly roleName: Schema.Literals<readonly ["workernode"]>;
}>;
export type ClustersResizeInput = typeof ClustersResizeInput.Type;
export declare const ClustersResizeOutput: Schema.Void;
export type ClustersResizeOutput = typeof ClustersResizeOutput.Type;
/**
 * Resizes the specified HDInsight cluster to the specified size.
 *
 * @param roleName - The constant value for the roleName
 */
export declare const ClustersResize: import("@distilled.cloud/core/client").OperationMethod<{
    readonly roleName: "workernode";
}, void, never, import("../credentials.ts").Credentials>;
export declare const ClustersRotateDiskEncryptionKeyInput: Schema.Struct<{}>;
export type ClustersRotateDiskEncryptionKeyInput = typeof ClustersRotateDiskEncryptionKeyInput.Type;
export declare const ClustersRotateDiskEncryptionKeyOutput: Schema.Void;
export type ClustersRotateDiskEncryptionKeyOutput = typeof ClustersRotateDiskEncryptionKeyOutput.Type;
/**
 * Rotate disk encryption key of the specified HDInsight cluster.
 */
export declare const ClustersRotateDiskEncryptionKey: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ClustersUpdateInput: Schema.Struct<{}>;
export type ClustersUpdateInput = typeof ClustersUpdateInput.Type;
export declare const ClustersUpdateOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type ClustersUpdateOutput = typeof ClustersUpdateOutput.Type;
/**
 * Patch HDInsight cluster with the specified parameters.
 */
export declare const ClustersUpdate: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ClustersUpdateAutoScaleConfigurationInput: Schema.Struct<{
    readonly roleName: Schema.Literals<readonly ["workernode"]>;
}>;
export type ClustersUpdateAutoScaleConfigurationInput = typeof ClustersUpdateAutoScaleConfigurationInput.Type;
export declare const ClustersUpdateAutoScaleConfigurationOutput: Schema.Void;
export type ClustersUpdateAutoScaleConfigurationOutput = typeof ClustersUpdateAutoScaleConfigurationOutput.Type;
/**
 * Updates the Autoscale Configuration for HDInsight cluster.
 *
 * @param roleName - The constant value for the roleName
 */
export declare const ClustersUpdateAutoScaleConfiguration: import("@distilled.cloud/core/client").OperationMethod<{
    readonly roleName: "workernode";
}, void, never, import("../credentials.ts").Credentials>;
export declare const ClustersUpdateGatewaySettingsInput: Schema.Struct<{}>;
export type ClustersUpdateGatewaySettingsInput = typeof ClustersUpdateGatewaySettingsInput.Type;
export declare const ClustersUpdateGatewaySettingsOutput: Schema.Void;
export type ClustersUpdateGatewaySettingsOutput = typeof ClustersUpdateGatewaySettingsOutput.Type;
/**
 * Configures the gateway settings on the specified cluster.
 */
export declare const ClustersUpdateGatewaySettings: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ClustersUpdateIdentityCertificateInput: Schema.Struct<{}>;
export type ClustersUpdateIdentityCertificateInput = typeof ClustersUpdateIdentityCertificateInput.Type;
export declare const ClustersUpdateIdentityCertificateOutput: Schema.Void;
export type ClustersUpdateIdentityCertificateOutput = typeof ClustersUpdateIdentityCertificateOutput.Type;
/**
 * Updates the cluster identity certificate.
 */
export declare const ClustersUpdateIdentityCertificate: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ConfigurationsGetInput: Schema.Struct<{}>;
export type ConfigurationsGetInput = typeof ConfigurationsGetInput.Type;
export declare const ConfigurationsGetOutput: Schema.$Record<Schema.String, Schema.String>;
export type ConfigurationsGetOutput = typeof ConfigurationsGetOutput.Type;
/**
 * The configuration object for the specified cluster. This API is not recommended and might be removed in the future. Please consider using List configurations API instead.
 */
export declare const ConfigurationsGet: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly [x: string]: string;
}, never, import("../credentials.ts").Credentials>;
export declare const ConfigurationsListInput: Schema.Struct<{}>;
export type ConfigurationsListInput = typeof ConfigurationsListInput.Type;
export declare const ConfigurationsListOutput: Schema.Struct<{
    readonly configurations: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.String>>>;
}>;
export type ConfigurationsListOutput = typeof ConfigurationsListOutput.Type;
/**
 * Gets all configuration information for an HDI cluster.
 */
export declare const ConfigurationsList: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly configurations?: {
        readonly [x: string]: {
            readonly [x: string]: string;
        };
    } | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsCreateInput: Schema.Struct<{}>;
export type ExtensionsCreateInput = typeof ExtensionsCreateInput.Type;
export declare const ExtensionsCreateOutput: Schema.Void;
export type ExtensionsCreateOutput = typeof ExtensionsCreateOutput.Type;
/**
 * Creates an HDInsight cluster extension.
 */
export declare const ExtensionsCreate: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsDeleteInput: Schema.Struct<{}>;
export type ExtensionsDeleteInput = typeof ExtensionsDeleteInput.Type;
export declare const ExtensionsDeleteOutput: Schema.Void;
export type ExtensionsDeleteOutput = typeof ExtensionsDeleteOutput.Type;
/**
 * Deletes the specified extension for HDInsight cluster.
 */
export declare const ExtensionsDelete: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsDisableAzureMonitorInput: Schema.Struct<{}>;
export type ExtensionsDisableAzureMonitorInput = typeof ExtensionsDisableAzureMonitorInput.Type;
export declare const ExtensionsDisableAzureMonitorOutput: Schema.Void;
export type ExtensionsDisableAzureMonitorOutput = typeof ExtensionsDisableAzureMonitorOutput.Type;
/**
 * Disables the Azure Monitor on the HDInsight cluster.
 */
export declare const ExtensionsDisableAzureMonitor: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsDisableMonitoringInput: Schema.Struct<{}>;
export type ExtensionsDisableMonitoringInput = typeof ExtensionsDisableMonitoringInput.Type;
export declare const ExtensionsDisableMonitoringOutput: Schema.Void;
export type ExtensionsDisableMonitoringOutput = typeof ExtensionsDisableMonitoringOutput.Type;
/**
 * Disables the Operations Management Suite (OMS) on the HDInsight cluster.
 */
export declare const ExtensionsDisableMonitoring: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsEnableAzureMonitorInput: Schema.Struct<{}>;
export type ExtensionsEnableAzureMonitorInput = typeof ExtensionsEnableAzureMonitorInput.Type;
export declare const ExtensionsEnableAzureMonitorOutput: Schema.Void;
export type ExtensionsEnableAzureMonitorOutput = typeof ExtensionsEnableAzureMonitorOutput.Type;
/**
 * Enables the Azure Monitor on the HDInsight cluster.
 */
export declare const ExtensionsEnableAzureMonitor: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsEnableMonitoringInput: Schema.Struct<{}>;
export type ExtensionsEnableMonitoringInput = typeof ExtensionsEnableMonitoringInput.Type;
export declare const ExtensionsEnableMonitoringOutput: Schema.Void;
export type ExtensionsEnableMonitoringOutput = typeof ExtensionsEnableMonitoringOutput.Type;
/**
 * Enables the Operations Management Suite (OMS) on the HDInsight cluster.
 */
export declare const ExtensionsEnableMonitoring: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsGetInput: Schema.Struct<{}>;
export type ExtensionsGetInput = typeof ExtensionsGetInput.Type;
export declare const ExtensionsGetOutput: Schema.Struct<{
    readonly clusterMonitoringEnabled: Schema.optional<Schema.Boolean>;
    readonly workspaceId: Schema.optional<Schema.String>;
}>;
export type ExtensionsGetOutput = typeof ExtensionsGetOutput.Type;
/**
 * Gets the extension properties for the specified HDInsight cluster extension.
 */
export declare const ExtensionsGet: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly clusterMonitoringEnabled?: boolean | undefined;
    readonly workspaceId?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsGetAzureAsyncOperationStatusInput: Schema.Struct<{}>;
export type ExtensionsGetAzureAsyncOperationStatusInput = typeof ExtensionsGetAzureAsyncOperationStatusInput.Type;
export declare const ExtensionsGetAzureAsyncOperationStatusOutput: Schema.Struct<{
    readonly status: Schema.optional<Schema.Literals<readonly ["InProgress", "Succeeded", "Failed"]>>;
    readonly error: Schema.optional<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
    }>>;
}>;
export type ExtensionsGetAzureAsyncOperationStatusOutput = typeof ExtensionsGetAzureAsyncOperationStatusOutput.Type;
/**
 * Gets the async operation status.
 */
export declare const ExtensionsGetAzureAsyncOperationStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly error?: {
        readonly code?: string | undefined;
        readonly message?: string | undefined;
    } | undefined;
    readonly status?: "Failed" | "InProgress" | "Succeeded" | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsGetAzureMonitorStatusInput: Schema.Struct<{}>;
export type ExtensionsGetAzureMonitorStatusInput = typeof ExtensionsGetAzureMonitorStatusInput.Type;
export declare const ExtensionsGetAzureMonitorStatusOutput: Schema.Struct<{
    readonly clusterMonitoringEnabled: Schema.optional<Schema.Boolean>;
    readonly workspaceId: Schema.optional<Schema.String>;
    readonly selectedConfigurations: Schema.optional<Schema.Struct<{
        readonly configurationVersion: Schema.optional<Schema.String>;
        readonly globalConfigurations: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
        readonly tableList: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly name: Schema.optional<Schema.String>;
        }>>>;
    }>>;
}>;
export type ExtensionsGetAzureMonitorStatusOutput = typeof ExtensionsGetAzureMonitorStatusOutput.Type;
/**
 * Gets the status of Azure Monitor on the HDInsight cluster.
 */
export declare const ExtensionsGetAzureMonitorStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly clusterMonitoringEnabled?: boolean | undefined;
    readonly selectedConfigurations?: {
        readonly configurationVersion?: string | undefined;
        readonly globalConfigurations?: {
            readonly [x: string]: string;
        } | undefined;
        readonly tableList?: readonly {
            readonly name?: string | undefined;
        }[] | undefined;
    } | undefined;
    readonly workspaceId?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ExtensionsGetMonitoringStatusInput: Schema.Struct<{}>;
export type ExtensionsGetMonitoringStatusInput = typeof ExtensionsGetMonitoringStatusInput.Type;
export declare const ExtensionsGetMonitoringStatusOutput: Schema.Struct<{
    readonly clusterMonitoringEnabled: Schema.optional<Schema.Boolean>;
    readonly workspaceId: Schema.optional<Schema.String>;
}>;
export type ExtensionsGetMonitoringStatusOutput = typeof ExtensionsGetMonitoringStatusOutput.Type;
/**
 * Gets the status of Operations Management Suite (OMS) on the HDInsight cluster.
 */
export declare const ExtensionsGetMonitoringStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly clusterMonitoringEnabled?: boolean | undefined;
    readonly workspaceId?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const LocationsCheckNameAvailabilityInput: Schema.Struct<{}>;
export type LocationsCheckNameAvailabilityInput = typeof LocationsCheckNameAvailabilityInput.Type;
export declare const LocationsCheckNameAvailabilityOutput: Schema.Struct<{
    readonly nameAvailable: Schema.optional<Schema.Boolean>;
    readonly reason: Schema.optional<Schema.String>;
    readonly message: Schema.optional<Schema.String>;
}>;
export type LocationsCheckNameAvailabilityOutput = typeof LocationsCheckNameAvailabilityOutput.Type;
/**
 * Check the cluster name is available or not.
 */
export declare const LocationsCheckNameAvailability: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly message?: string | undefined;
    readonly nameAvailable?: boolean | undefined;
    readonly reason?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const LocationsGetAzureAsyncOperationStatusInput: Schema.Struct<{}>;
export type LocationsGetAzureAsyncOperationStatusInput = typeof LocationsGetAzureAsyncOperationStatusInput.Type;
export declare const LocationsGetAzureAsyncOperationStatusOutput: Schema.Struct<{
    readonly status: Schema.optional<Schema.Literals<readonly ["InProgress", "Succeeded", "Failed"]>>;
    readonly error: Schema.optional<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
    }>>;
}>;
export type LocationsGetAzureAsyncOperationStatusOutput = typeof LocationsGetAzureAsyncOperationStatusOutput.Type;
/**
 * Get the async operation status.
 */
export declare const LocationsGetAzureAsyncOperationStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly error?: {
        readonly code?: string | undefined;
        readonly message?: string | undefined;
    } | undefined;
    readonly status?: "Failed" | "InProgress" | "Succeeded" | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const LocationsGetCapabilitiesInput: Schema.Struct<{}>;
export type LocationsGetCapabilitiesInput = typeof LocationsGetCapabilitiesInput.Type;
export declare const LocationsGetCapabilitiesOutput: Schema.Struct<{
    readonly versions: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
        readonly available: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly friendlyName: Schema.optional<Schema.String>;
            readonly displayName: Schema.optional<Schema.String>;
            readonly isDefault: Schema.optional<Schema.Boolean>;
            readonly componentVersions: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
        }>>>;
    }>>>;
    readonly regions: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
        readonly available: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
    readonly features: Schema.optional<Schema.$Array<Schema.String>>;
    readonly quota: Schema.optional<Schema.Struct<{
        readonly coresUsed: Schema.optional<Schema.Number>;
        readonly maxCoresAllowed: Schema.optional<Schema.Number>;
        readonly regionalQuotas: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly regionName: Schema.optional<Schema.String>;
            readonly coresUsed: Schema.optional<Schema.Number>;
            readonly coresAvailable: Schema.optional<Schema.Number>;
        }>>>;
    }>>;
}>;
export type LocationsGetCapabilitiesOutput = typeof LocationsGetCapabilitiesOutput.Type;
/**
 * Gets the capabilities for the specified location.
 */
export declare const LocationsGetCapabilities: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly features?: readonly string[] | undefined;
    readonly quota?: {
        readonly coresUsed?: number | undefined;
        readonly maxCoresAllowed?: number | undefined;
        readonly regionalQuotas?: readonly {
            readonly coresAvailable?: number | undefined;
            readonly coresUsed?: number | undefined;
            readonly regionName?: string | undefined;
        }[] | undefined;
    } | undefined;
    readonly regions?: {
        readonly [x: string]: {
            readonly available?: readonly string[] | undefined;
        };
    } | undefined;
    readonly versions?: {
        readonly [x: string]: {
            readonly available?: readonly {
                readonly componentVersions?: {
                    readonly [x: string]: string;
                } | undefined;
                readonly displayName?: string | undefined;
                readonly friendlyName?: string | undefined;
                readonly isDefault?: boolean | undefined;
            }[] | undefined;
        };
    } | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const LocationsListBillingSpecsInput: Schema.Struct<{}>;
export type LocationsListBillingSpecsInput = typeof LocationsListBillingSpecsInput.Type;
export declare const LocationsListBillingSpecsOutput: Schema.Struct<{
    readonly vmSizes: Schema.optional<Schema.$Array<Schema.String>>;
    readonly vmSizesWithEncryptionAtHost: Schema.optional<Schema.$Array<Schema.String>>;
    readonly vmSizeFilters: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly filterMode: Schema.optional<Schema.Literals<readonly ["Exclude", "Include", "Recommend", "Default"]>>;
        readonly regions: Schema.optional<Schema.$Array<Schema.String>>;
        readonly clusterFlavors: Schema.optional<Schema.$Array<Schema.String>>;
        readonly nodeTypes: Schema.optional<Schema.$Array<Schema.String>>;
        readonly clusterVersions: Schema.optional<Schema.$Array<Schema.String>>;
        readonly osType: Schema.optional<Schema.$Array<Schema.Literals<readonly ["Windows", "Linux"]>>>;
        readonly vmSizes: Schema.optional<Schema.$Array<Schema.String>>;
        readonly espApplied: Schema.optional<Schema.String>;
        readonly computeIsolationSupported: Schema.optional<Schema.String>;
    }>>>;
    readonly vmSizeProperties: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly name: Schema.optional<Schema.String>;
        readonly cores: Schema.optional<Schema.Number>;
        readonly dataDiskStorageTier: Schema.optional<Schema.String>;
        readonly label: Schema.optional<Schema.String>;
        readonly maxDataDiskCount: Schema.optional<Schema.Number>;
        readonly memoryInMb: Schema.optional<Schema.Number>;
        readonly supportedByVirtualMachines: Schema.optional<Schema.Boolean>;
        readonly supportedByWebWorkerRoles: Schema.optional<Schema.Boolean>;
        readonly virtualMachineResourceDiskSizeInMb: Schema.optional<Schema.Number>;
        readonly webWorkerResourceDiskSizeInMb: Schema.optional<Schema.Number>;
    }>>>;
    readonly billingResources: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly region: Schema.optional<Schema.String>;
        readonly billingMeters: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly meterParameter: Schema.optional<Schema.String>;
            readonly meter: Schema.optional<Schema.String>;
            readonly unit: Schema.optional<Schema.String>;
        }>>>;
        readonly diskBillingMeters: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly diskRpMeter: Schema.optional<Schema.String>;
            readonly sku: Schema.optional<Schema.String>;
            readonly tier: Schema.optional<Schema.Literals<readonly ["Standard", "Premium"]>>;
        }>>>;
    }>>>;
}>;
export type LocationsListBillingSpecsOutput = typeof LocationsListBillingSpecsOutput.Type;
/**
 * Lists the billingSpecs for the specified subscription and location.
 */
export declare const LocationsListBillingSpecs: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly billingResources?: readonly {
        readonly billingMeters?: readonly {
            readonly meter?: string | undefined;
            readonly meterParameter?: string | undefined;
            readonly unit?: string | undefined;
        }[] | undefined;
        readonly diskBillingMeters?: readonly {
            readonly diskRpMeter?: string | undefined;
            readonly sku?: string | undefined;
            readonly tier?: "Premium" | "Standard" | undefined;
        }[] | undefined;
        readonly region?: string | undefined;
    }[] | undefined;
    readonly vmSizeFilters?: readonly {
        readonly clusterFlavors?: readonly string[] | undefined;
        readonly clusterVersions?: readonly string[] | undefined;
        readonly computeIsolationSupported?: string | undefined;
        readonly espApplied?: string | undefined;
        readonly filterMode?: "Default" | "Exclude" | "Include" | "Recommend" | undefined;
        readonly nodeTypes?: readonly string[] | undefined;
        readonly osType?: readonly ("Linux" | "Windows")[] | undefined;
        readonly regions?: readonly string[] | undefined;
        readonly vmSizes?: readonly string[] | undefined;
    }[] | undefined;
    readonly vmSizeProperties?: readonly {
        readonly cores?: number | undefined;
        readonly dataDiskStorageTier?: string | undefined;
        readonly label?: string | undefined;
        readonly maxDataDiskCount?: number | undefined;
        readonly memoryInMb?: number | undefined;
        readonly name?: string | undefined;
        readonly supportedByVirtualMachines?: boolean | undefined;
        readonly supportedByWebWorkerRoles?: boolean | undefined;
        readonly virtualMachineResourceDiskSizeInMb?: number | undefined;
        readonly webWorkerResourceDiskSizeInMb?: number | undefined;
    }[] | undefined;
    readonly vmSizes?: readonly string[] | undefined;
    readonly vmSizesWithEncryptionAtHost?: readonly string[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const LocationsListUsagesInput: Schema.Struct<{}>;
export type LocationsListUsagesInput = typeof LocationsListUsagesInput.Type;
export declare const LocationsListUsagesOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly unit: Schema.optional<Schema.String>;
        readonly currentValue: Schema.optional<Schema.Number>;
        readonly limit: Schema.optional<Schema.Number>;
        readonly name: Schema.optional<Schema.Struct<{
            readonly value: Schema.optional<Schema.String>;
            readonly localizedValue: Schema.optional<Schema.String>;
        }>>;
    }>>>;
}>;
export type LocationsListUsagesOutput = typeof LocationsListUsagesOutput.Type;
/**
 * Lists the usages for the specified location.
 */
export declare const LocationsListUsages: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly value?: readonly {
        readonly currentValue?: number | undefined;
        readonly limit?: number | undefined;
        readonly name?: {
            readonly localizedValue?: string | undefined;
            readonly value?: string | undefined;
        } | undefined;
        readonly unit?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const LocationsValidateClusterCreateRequestInput: Schema.Struct<{}>;
export type LocationsValidateClusterCreateRequestInput = typeof LocationsValidateClusterCreateRequestInput.Type;
export declare const LocationsValidateClusterCreateRequestOutput: Schema.Struct<{
    readonly validationErrors: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
        readonly errorResource: Schema.optional<Schema.String>;
        readonly messageArguments: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
    readonly validationWarnings: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
        readonly errorResource: Schema.optional<Schema.String>;
        readonly messageArguments: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
    readonly estimatedCreationDuration: Schema.optional<Schema.String>;
    readonly aaddsResourcesDetails: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly domainName: Schema.optional<Schema.String>;
        readonly initialSyncComplete: Schema.optional<Schema.Boolean>;
        readonly ldapsEnabled: Schema.optional<Schema.Boolean>;
        readonly ldapsPublicCertificateInBase64: Schema.optional<Schema.String>;
        readonly resourceId: Schema.optional<Schema.String>;
        readonly subnetId: Schema.optional<Schema.String>;
        readonly tenantId: Schema.optional<Schema.String>;
    }>>>;
}>;
export type LocationsValidateClusterCreateRequestOutput = typeof LocationsValidateClusterCreateRequestOutput.Type;
/**
 * Validate the cluster create request spec is valid or not.
 */
export declare const LocationsValidateClusterCreateRequest: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly aaddsResourcesDetails?: readonly {
        readonly domainName?: string | undefined;
        readonly initialSyncComplete?: boolean | undefined;
        readonly ldapsEnabled?: boolean | undefined;
        readonly ldapsPublicCertificateInBase64?: string | undefined;
        readonly resourceId?: string | undefined;
        readonly subnetId?: string | undefined;
        readonly tenantId?: string | undefined;
    }[] | undefined;
    readonly estimatedCreationDuration?: string | undefined;
    readonly validationErrors?: readonly {
        readonly code?: string | undefined;
        readonly errorResource?: string | undefined;
        readonly message?: string | undefined;
        readonly messageArguments?: readonly string[] | undefined;
    }[] | undefined;
    readonly validationWarnings?: readonly {
        readonly code?: string | undefined;
        readonly errorResource?: string | undefined;
        readonly message?: string | undefined;
        readonly messageArguments?: readonly string[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const OperationsListInput: Schema.Struct<{}>;
export type OperationsListInput = typeof OperationsListInput.Type;
export declare const OperationsListOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly name: Schema.optional<Schema.String>;
        readonly display: Schema.optional<Schema.Struct<{
            readonly provider: Schema.optional<Schema.String>;
            readonly resource: Schema.optional<Schema.String>;
            readonly operation: Schema.optional<Schema.String>;
            readonly description: Schema.optional<Schema.String>;
        }>>;
        readonly properties: Schema.optional<Schema.Struct<{
            readonly serviceSpecification: Schema.optional<Schema.Struct<{
                readonly metricSpecifications: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly name: Schema.optional<Schema.String>;
                    readonly displayName: Schema.optional<Schema.String>;
                    readonly displayDescription: Schema.optional<Schema.String>;
                    readonly unit: Schema.optional<Schema.String>;
                    readonly aggregationType: Schema.optional<Schema.String>;
                    readonly supportedAggregationTypes: Schema.optional<Schema.$Array<Schema.String>>;
                    readonly supportedTimeGrainTypes: Schema.optional<Schema.$Array<Schema.String>>;
                    readonly enableRegionalMdmAccount: Schema.optional<Schema.Boolean>;
                    readonly sourceMdmAccount: Schema.optional<Schema.String>;
                    readonly sourceMdmNamespace: Schema.optional<Schema.String>;
                    readonly metricFilterPattern: Schema.optional<Schema.String>;
                    readonly fillGapWithZero: Schema.optional<Schema.Boolean>;
                    readonly category: Schema.optional<Schema.String>;
                    readonly resourceIdDimensionNameOverride: Schema.optional<Schema.String>;
                    readonly isInternal: Schema.optional<Schema.Boolean>;
                    readonly delegateMetricNameOverride: Schema.optional<Schema.String>;
                    readonly dimensions: Schema.optional<Schema.$Array<Schema.Struct<{
                        readonly name: Schema.optional<Schema.String>;
                        readonly displayName: Schema.optional<Schema.String>;
                        readonly internalName: Schema.optional<Schema.String>;
                        readonly toBeExportedForShoebox: Schema.optional<Schema.Boolean>;
                    }>>>;
                }>>>;
            }>>;
        }>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type OperationsListOutput = typeof OperationsListOutput.Type;
/**
 * Lists all of the available HDInsight REST API operations.
 */
export declare const OperationsList: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly display?: {
            readonly description?: string | undefined;
            readonly operation?: string | undefined;
            readonly provider?: string | undefined;
            readonly resource?: string | undefined;
        } | undefined;
        readonly name?: string | undefined;
        readonly properties?: {
            readonly serviceSpecification?: {
                readonly metricSpecifications?: readonly {
                    readonly aggregationType?: string | undefined;
                    readonly category?: string | undefined;
                    readonly delegateMetricNameOverride?: string | undefined;
                    readonly dimensions?: readonly {
                        readonly displayName?: string | undefined;
                        readonly internalName?: string | undefined;
                        readonly name?: string | undefined;
                        readonly toBeExportedForShoebox?: boolean | undefined;
                    }[] | undefined;
                    readonly displayDescription?: string | undefined;
                    readonly displayName?: string | undefined;
                    readonly enableRegionalMdmAccount?: boolean | undefined;
                    readonly fillGapWithZero?: boolean | undefined;
                    readonly isInternal?: boolean | undefined;
                    readonly metricFilterPattern?: string | undefined;
                    readonly name?: string | undefined;
                    readonly resourceIdDimensionNameOverride?: string | undefined;
                    readonly sourceMdmAccount?: string | undefined;
                    readonly sourceMdmNamespace?: string | undefined;
                    readonly supportedAggregationTypes?: readonly string[] | undefined;
                    readonly supportedTimeGrainTypes?: readonly string[] | undefined;
                    readonly unit?: string | undefined;
                }[] | undefined;
            } | undefined;
        } | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateEndpointConnectionsCreateOrUpdateInput: Schema.Struct<{}>;
export type PrivateEndpointConnectionsCreateOrUpdateInput = typeof PrivateEndpointConnectionsCreateOrUpdateInput.Type;
export declare const PrivateEndpointConnectionsCreateOrUpdateOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type PrivateEndpointConnectionsCreateOrUpdateOutput = typeof PrivateEndpointConnectionsCreateOrUpdateOutput.Type;
/**
 * Approve or reject a private endpoint connection manually.
 */
export declare const PrivateEndpointConnectionsCreateOrUpdate: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateEndpointConnectionsDeleteInput: Schema.Struct<{}>;
export type PrivateEndpointConnectionsDeleteInput = typeof PrivateEndpointConnectionsDeleteInput.Type;
export declare const PrivateEndpointConnectionsDeleteOutput: Schema.Void;
export type PrivateEndpointConnectionsDeleteOutput = typeof PrivateEndpointConnectionsDeleteOutput.Type;
/**
 * Deletes the specific private endpoint connection.
 */
export declare const PrivateEndpointConnectionsDelete: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateEndpointConnectionsGetInput: Schema.Struct<{}>;
export type PrivateEndpointConnectionsGetInput = typeof PrivateEndpointConnectionsGetInput.Type;
export declare const PrivateEndpointConnectionsGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type PrivateEndpointConnectionsGetOutput = typeof PrivateEndpointConnectionsGetOutput.Type;
/**
 * Gets the specific private endpoint connection.
 */
export declare const PrivateEndpointConnectionsGet: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateEndpointConnectionsListByClusterInput: Schema.Struct<{}>;
export type PrivateEndpointConnectionsListByClusterInput = typeof PrivateEndpointConnectionsListByClusterInput.Type;
export declare const PrivateEndpointConnectionsListByClusterOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateEndpointConnectionsListByClusterOutput = typeof PrivateEndpointConnectionsListByClusterOutput.Type;
/**
 * Lists the private endpoint connections for a HDInsight cluster.
 */
export declare const PrivateEndpointConnectionsListByCluster: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateLinkResourcesGetInput: Schema.Struct<{}>;
export type PrivateLinkResourcesGetInput = typeof PrivateLinkResourcesGetInput.Type;
export declare const PrivateLinkResourcesGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
}>;
export type PrivateLinkResourcesGetOutput = typeof PrivateLinkResourcesGetOutput.Type;
/**
 * Gets the specific private link resource.
 */
export declare const PrivateLinkResourcesGet: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateLinkResourcesListByClusterInput: Schema.Struct<{}>;
export type PrivateLinkResourcesListByClusterInput = typeof PrivateLinkResourcesListByClusterInput.Type;
export declare const PrivateLinkResourcesListByClusterOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
    }>>>;
}>;
export type PrivateLinkResourcesListByClusterOutput = typeof PrivateLinkResourcesListByClusterOutput.Type;
/**
 * Lists the private link resources in a HDInsight cluster.
 */
export declare const PrivateLinkResourcesListByCluster: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ScriptActionsDeleteInput: Schema.Struct<{}>;
export type ScriptActionsDeleteInput = typeof ScriptActionsDeleteInput.Type;
export declare const ScriptActionsDeleteOutput: Schema.Void;
export type ScriptActionsDeleteOutput = typeof ScriptActionsDeleteOutput.Type;
/**
 * Deletes a specified persisted script action of the cluster.
 */
export declare const ScriptActionsDelete: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const ScriptActionsGetExecutionAsyncOperationStatusInput: Schema.Struct<{}>;
export type ScriptActionsGetExecutionAsyncOperationStatusInput = typeof ScriptActionsGetExecutionAsyncOperationStatusInput.Type;
export declare const ScriptActionsGetExecutionAsyncOperationStatusOutput: Schema.Struct<{
    readonly status: Schema.optional<Schema.Literals<readonly ["InProgress", "Succeeded", "Failed"]>>;
    readonly error: Schema.optional<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
    }>>;
}>;
export type ScriptActionsGetExecutionAsyncOperationStatusOutput = typeof ScriptActionsGetExecutionAsyncOperationStatusOutput.Type;
/**
 * Gets the async operation status of execution operation.
 */
export declare const ScriptActionsGetExecutionAsyncOperationStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly error?: {
        readonly code?: string | undefined;
        readonly message?: string | undefined;
    } | undefined;
    readonly status?: "Failed" | "InProgress" | "Succeeded" | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ScriptActionsGetExecutionDetailInput: Schema.Struct<{}>;
export type ScriptActionsGetExecutionDetailInput = typeof ScriptActionsGetExecutionDetailInput.Type;
export declare const ScriptActionsGetExecutionDetailOutput: Schema.Struct<{
    readonly name: Schema.String;
    readonly uri: Schema.String;
    readonly parameters: Schema.optional<Schema.String>;
    readonly roles: Schema.$Array<Schema.String>;
    readonly applicationName: Schema.optional<Schema.String>;
}>;
export type ScriptActionsGetExecutionDetailOutput = typeof ScriptActionsGetExecutionDetailOutput.Type;
/**
 * Gets the script execution detail for the given script execution ID.
 */
export declare const ScriptActionsGetExecutionDetail: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly applicationName?: string | undefined;
    readonly name: string;
    readonly parameters?: string | undefined;
    readonly roles: readonly string[];
    readonly uri: string;
}, never, import("../credentials.ts").Credentials>;
export declare const ScriptActionsListByClusterInput: Schema.Struct<{}>;
export type ScriptActionsListByClusterInput = typeof ScriptActionsListByClusterInput.Type;
export declare const ScriptActionsListByClusterOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly name: Schema.String;
        readonly uri: Schema.String;
        readonly parameters: Schema.optional<Schema.String>;
        readonly roles: Schema.$Array<Schema.String>;
        readonly applicationName: Schema.optional<Schema.String>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type ScriptActionsListByClusterOutput = typeof ScriptActionsListByClusterOutput.Type;
/**
 * Lists all the persisted script actions for the specified cluster.
 */
export declare const ScriptActionsListByCluster: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly applicationName?: string | undefined;
        readonly name: string;
        readonly parameters?: string | undefined;
        readonly roles: readonly string[];
        readonly uri: string;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ScriptExecutionHistoryListByClusterInput: Schema.Struct<{}>;
export type ScriptExecutionHistoryListByClusterInput = typeof ScriptExecutionHistoryListByClusterInput.Type;
export declare const ScriptExecutionHistoryListByClusterOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly name: Schema.String;
        readonly uri: Schema.String;
        readonly parameters: Schema.optional<Schema.String>;
        readonly roles: Schema.$Array<Schema.String>;
        readonly applicationName: Schema.optional<Schema.String>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type ScriptExecutionHistoryListByClusterOutput = typeof ScriptExecutionHistoryListByClusterOutput.Type;
/**
 * Lists all scripts' execution history for the specified cluster.
 */
export declare const ScriptExecutionHistoryListByCluster: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly applicationName?: string | undefined;
        readonly name: string;
        readonly parameters?: string | undefined;
        readonly roles: readonly string[];
        readonly uri: string;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const ScriptExecutionHistoryPromoteInput: Schema.Struct<{}>;
export type ScriptExecutionHistoryPromoteInput = typeof ScriptExecutionHistoryPromoteInput.Type;
export declare const ScriptExecutionHistoryPromoteOutput: Schema.Void;
export type ScriptExecutionHistoryPromoteOutput = typeof ScriptExecutionHistoryPromoteOutput.Type;
/**
 * Promotes the specified ad-hoc script execution to a persisted script.
 */
export declare const ScriptExecutionHistoryPromote: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
export declare const VirtualMachinesGetAsyncOperationStatusInput: Schema.Struct<{}>;
export type VirtualMachinesGetAsyncOperationStatusInput = typeof VirtualMachinesGetAsyncOperationStatusInput.Type;
export declare const VirtualMachinesGetAsyncOperationStatusOutput: Schema.Struct<{
    readonly status: Schema.optional<Schema.Literals<readonly ["InProgress", "Succeeded", "Failed"]>>;
    readonly error: Schema.optional<Schema.Struct<{
        readonly code: Schema.optional<Schema.String>;
        readonly message: Schema.optional<Schema.String>;
    }>>;
}>;
export type VirtualMachinesGetAsyncOperationStatusOutput = typeof VirtualMachinesGetAsyncOperationStatusOutput.Type;
/**
 * Gets the async operation status.
 */
export declare const VirtualMachinesGetAsyncOperationStatus: import("@distilled.cloud/core/client").OperationMethod<{}, {
    readonly error?: {
        readonly code?: string | undefined;
        readonly message?: string | undefined;
    } | undefined;
    readonly status?: "Failed" | "InProgress" | "Succeeded" | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const VirtualMachinesListHostsInput: Schema.Struct<{}>;
export type VirtualMachinesListHostsInput = typeof VirtualMachinesListHostsInput.Type;
export declare const VirtualMachinesListHostsOutput: Schema.$Array<Schema.Struct<{
    readonly name: Schema.optional<Schema.String>;
    readonly fqdn: Schema.optional<Schema.String>;
    readonly effectiveDiskEncryptionKeyUrl: Schema.optional<Schema.String>;
}>>;
export type VirtualMachinesListHostsOutput = typeof VirtualMachinesListHostsOutput.Type;
/**
 * Lists the HDInsight clusters hosts
 */
export declare const VirtualMachinesListHosts: import("@distilled.cloud/core/client").OperationMethod<{}, readonly {
    readonly effectiveDiskEncryptionKeyUrl?: string | undefined;
    readonly fqdn?: string | undefined;
    readonly name?: string | undefined;
}[], never, import("../credentials.ts").Credentials>;
export declare const VirtualMachinesRestartHostsInput: Schema.Struct<{}>;
export type VirtualMachinesRestartHostsInput = typeof VirtualMachinesRestartHostsInput.Type;
export declare const VirtualMachinesRestartHostsOutput: Schema.Void;
export type VirtualMachinesRestartHostsOutput = typeof VirtualMachinesRestartHostsOutput.Type;
/**
 * Restarts the specified HDInsight cluster hosts.
 */
export declare const VirtualMachinesRestartHosts: import("@distilled.cloud/core/client").OperationMethod<{}, void, never, import("../credentials.ts").Credentials>;
//# sourceMappingURL=hdinsight.d.ts.map