import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type ExceptionMessage = string;
export type RequestId = string;
export type ServiceCode = string;
export type QuotaCode = string;
export type AwsRegion = string;
export type AmazonResourceName = string;
export type ExcludedService = string;
export type QuotaName = string;
export type ServiceName = string;
export type QuotaArn = string;
export type QuotaValue = number;
export type QuotaUnit = string;
export type QuotaAdjustable = boolean;
export type GlobalQuota = boolean;
export type QuotaMetricNamespace = string;
export type QuotaMetricName = string;
export type MetricDimensionName = string;
export type MetricDimensionValue = string;
export type Statistic = string;
export type PeriodValue = number;
export type ErrorMessage = string;
export type QuotaContextScopeType = string;
export type QuotaContextId = string;
export type QuotaDescription = string;
export type ReportId = string;
export type NextToken = string;
export type MaxResultsUtilization = number;
export type TotalCount = number;
export type UtilizationPct = number;
export type DefaultValue = number;
export type AppliedValue = number;
export type ReportErrorCode = string;
export type ReportErrorMessage = string;
export type CustomerServiceEngagementId = string;
export type Requester = string;
export type MaxResults = number;
export type TagKey = string;
export type TagValue = string;
export type SupportCaseAllowed = boolean;
export type ExcludedLimit = string;
export type ReportMessage = string;
export interface AssociateServiceQuotaTemplateRequest {
}
export declare const AssociateServiceQuotaTemplateRequest: S.Schema<AssociateServiceQuotaTemplateRequest>;
export interface AssociateServiceQuotaTemplateResponse {
}
export declare const AssociateServiceQuotaTemplateResponse: S.Schema<AssociateServiceQuotaTemplateResponse>;
export interface CreateSupportCaseRequest {
    RequestId: string;
}
export declare const CreateSupportCaseRequest: S.Schema<CreateSupportCaseRequest>;
export interface CreateSupportCaseResponse {
}
export declare const CreateSupportCaseResponse: S.Schema<CreateSupportCaseResponse>;
export interface DeleteServiceQuotaIncreaseRequestFromTemplateRequest {
    ServiceCode: string;
    QuotaCode: string;
    AwsRegion: string;
}
export declare const DeleteServiceQuotaIncreaseRequestFromTemplateRequest: S.Schema<DeleteServiceQuotaIncreaseRequestFromTemplateRequest>;
export interface DeleteServiceQuotaIncreaseRequestFromTemplateResponse {
}
export declare const DeleteServiceQuotaIncreaseRequestFromTemplateResponse: S.Schema<DeleteServiceQuotaIncreaseRequestFromTemplateResponse>;
export interface DisassociateServiceQuotaTemplateRequest {
}
export declare const DisassociateServiceQuotaTemplateRequest: S.Schema<DisassociateServiceQuotaTemplateRequest>;
export interface DisassociateServiceQuotaTemplateResponse {
}
export declare const DisassociateServiceQuotaTemplateResponse: S.Schema<DisassociateServiceQuotaTemplateResponse>;
export interface GetAssociationForServiceQuotaTemplateRequest {
}
export declare const GetAssociationForServiceQuotaTemplateRequest: S.Schema<GetAssociationForServiceQuotaTemplateRequest>;
export type ServiceQuotaTemplateAssociationStatus = "ASSOCIATED" | "DISASSOCIATED" | (string & {});
export declare const ServiceQuotaTemplateAssociationStatus: S.String;
export interface GetAssociationForServiceQuotaTemplateResponse {
    ServiceQuotaTemplateAssociationStatus?: ServiceQuotaTemplateAssociationStatus;
}
export declare const GetAssociationForServiceQuotaTemplateResponse: S.Schema<GetAssociationForServiceQuotaTemplateResponse>;
export interface GetAutoManagementConfigurationRequest {
}
export declare const GetAutoManagementConfigurationRequest: S.Schema<GetAutoManagementConfigurationRequest>;
export type OptInLevel = "ACCOUNT" | (string & {});
export declare const OptInLevel: S.String;
export type OptInType = "NotifyOnly" | "NotifyAndAdjust" | (string & {});
export declare const OptInType: S.String;
export type OptInStatus = "ENABLED" | "DISABLED" | (string & {});
export declare const OptInStatus: S.String;
export interface QuotaInfo {
    QuotaCode?: string;
    QuotaName?: string;
}
export declare const QuotaInfo: S.Schema<QuotaInfo>;
export type QuotaInfoList = QuotaInfo[];
export declare const QuotaInfoList: S.$Array<S.Schema<QuotaInfo>>;
export type ExclusionQuotaList = {
    [key: string]: QuotaInfo[] | undefined;
};
export declare const ExclusionQuotaList: S.$Record<S.String, S.optional<S.$Array<S.Schema<QuotaInfo>>>>;
export interface GetAutoManagementConfigurationResponse {
    OptInLevel?: OptInLevel;
    OptInType?: OptInType;
    NotificationArn?: string;
    OptInStatus?: OptInStatus;
    ExclusionList?: {
        [key: string]: QuotaInfo[] | undefined;
    };
}
export declare const GetAutoManagementConfigurationResponse: S.Schema<GetAutoManagementConfigurationResponse>;
export interface GetAWSDefaultServiceQuotaRequest {
    ServiceCode: string;
    QuotaCode: string;
}
export declare const GetAWSDefaultServiceQuotaRequest: S.Schema<GetAWSDefaultServiceQuotaRequest>;
export type MetricDimensionsMapDefinition = {
    [key: string]: string | undefined;
};
export declare const MetricDimensionsMapDefinition: S.$Record<S.String, S.optional<S.String>>;
export interface MetricInfo {
    MetricNamespace?: string;
    MetricName?: string;
    MetricDimensions?: {
        [key: string]: string | undefined;
    };
    MetricStatisticRecommendation?: string;
}
export declare const MetricInfo: S.Schema<MetricInfo>;
export type PeriodUnit = "MICROSECOND" | "MILLISECOND" | "SECOND" | "MINUTE" | "HOUR" | "DAY" | "WEEK" | (string & {});
export declare const PeriodUnit: S.String;
export interface QuotaPeriod {
    PeriodValue?: number;
    PeriodUnit?: PeriodUnit;
}
export declare const QuotaPeriod: S.Schema<QuotaPeriod>;
export type ErrorCode = "DEPENDENCY_ACCESS_DENIED_ERROR" | "DEPENDENCY_THROTTLING_ERROR" | "DEPENDENCY_SERVICE_ERROR" | "SERVICE_QUOTA_NOT_AVAILABLE_ERROR" | (string & {});
export declare const ErrorCode: S.String;
export interface ErrorReason {
    ErrorCode?: ErrorCode;
    ErrorMessage?: string;
}
export declare const ErrorReason: S.Schema<ErrorReason>;
export type AppliedLevelEnum = "ACCOUNT" | "RESOURCE" | "ALL" | (string & {});
export declare const AppliedLevelEnum: S.String;
export type QuotaContextScope = "RESOURCE" | "ACCOUNT" | (string & {});
export declare const QuotaContextScope: S.String;
export interface QuotaContextInfo {
    ContextScope?: QuotaContextScope;
    ContextScopeType?: string;
    ContextId?: string;
}
export declare const QuotaContextInfo: S.Schema<QuotaContextInfo>;
export interface ServiceQuota {
    ServiceCode?: string;
    ServiceName?: string;
    QuotaArn?: string;
    QuotaCode?: string;
    QuotaName?: string;
    Value?: number;
    Unit?: string;
    Adjustable?: boolean;
    GlobalQuota?: boolean;
    UsageMetric?: MetricInfo;
    Period?: QuotaPeriod;
    ErrorReason?: ErrorReason;
    QuotaAppliedAtLevel?: AppliedLevelEnum;
    QuotaContext?: QuotaContextInfo;
    Description?: string;
}
export declare const ServiceQuota: S.Schema<ServiceQuota>;
export interface GetAWSDefaultServiceQuotaResponse {
    Quota?: ServiceQuota;
}
export declare const GetAWSDefaultServiceQuotaResponse: S.Schema<GetAWSDefaultServiceQuotaResponse>;
export interface GetQuotaUtilizationReportRequest {
    ReportId: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const GetQuotaUtilizationReportRequest: S.Schema<GetQuotaUtilizationReportRequest>;
export type ReportStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED" | (string & {});
export declare const ReportStatus: S.String;
export interface QuotaUtilizationInfo {
    QuotaCode?: string;
    ServiceCode?: string;
    QuotaName?: string;
    Namespace?: string;
    Utilization?: number;
    DefaultValue?: number;
    AppliedValue?: number;
    ServiceName?: string;
    Adjustable?: boolean;
}
export declare const QuotaUtilizationInfo: S.Schema<QuotaUtilizationInfo>;
export type QuotaUtilizationInfoList = QuotaUtilizationInfo[];
export declare const QuotaUtilizationInfoList: S.$Array<S.Schema<QuotaUtilizationInfo>>;
export interface GetQuotaUtilizationReportResponse {
    ReportId?: string;
    Status?: ReportStatus;
    GeneratedAt?: Date;
    TotalCount?: number;
    Quotas?: QuotaUtilizationInfo[];
    NextToken?: string;
    ErrorCode?: string;
    ErrorMessage?: string;
}
export declare const GetQuotaUtilizationReportResponse: S.Schema<GetQuotaUtilizationReportResponse>;
export interface GetRequestedServiceQuotaChangeRequest {
    RequestId: string;
}
export declare const GetRequestedServiceQuotaChangeRequest: S.Schema<GetRequestedServiceQuotaChangeRequest>;
export type RequestType = "AutomaticManagement" | (string & {});
export declare const RequestType: S.String;
export type RequestStatus = "PENDING" | "CASE_OPENED" | "APPROVED" | "DENIED" | "CASE_CLOSED" | "NOT_APPROVED" | "INVALID_REQUEST" | (string & {});
export declare const RequestStatus: S.String;
export interface RequestedServiceQuotaChange {
    Id?: string;
    RequestType?: RequestType;
    CaseId?: string;
    ServiceCode?: string;
    ServiceName?: string;
    QuotaCode?: string;
    QuotaName?: string;
    DesiredValue?: number;
    Status?: RequestStatus;
    Created?: Date;
    LastUpdated?: Date;
    Requester?: string;
    QuotaArn?: string;
    GlobalQuota?: boolean;
    Unit?: string;
    QuotaRequestedAtLevel?: AppliedLevelEnum;
    QuotaContext?: QuotaContextInfo;
}
export declare const RequestedServiceQuotaChange: S.Schema<RequestedServiceQuotaChange>;
export interface GetRequestedServiceQuotaChangeResponse {
    RequestedQuota?: RequestedServiceQuotaChange;
}
export declare const GetRequestedServiceQuotaChangeResponse: S.Schema<GetRequestedServiceQuotaChangeResponse>;
export interface GetServiceQuotaRequest {
    ServiceCode: string;
    QuotaCode: string;
    ContextId?: string;
}
export declare const GetServiceQuotaRequest: S.Schema<GetServiceQuotaRequest>;
export interface GetServiceQuotaResponse {
    Quota?: ServiceQuota;
}
export declare const GetServiceQuotaResponse: S.Schema<GetServiceQuotaResponse>;
export interface GetServiceQuotaIncreaseRequestFromTemplateRequest {
    ServiceCode: string;
    QuotaCode: string;
    AwsRegion: string;
}
export declare const GetServiceQuotaIncreaseRequestFromTemplateRequest: S.Schema<GetServiceQuotaIncreaseRequestFromTemplateRequest>;
export interface ServiceQuotaIncreaseRequestInTemplate {
    ServiceCode?: string;
    ServiceName?: string;
    QuotaCode?: string;
    QuotaName?: string;
    DesiredValue?: number;
    AwsRegion?: string;
    Unit?: string;
    GlobalQuota?: boolean;
}
export declare const ServiceQuotaIncreaseRequestInTemplate: S.Schema<ServiceQuotaIncreaseRequestInTemplate>;
export interface GetServiceQuotaIncreaseRequestFromTemplateResponse {
    ServiceQuotaIncreaseRequestInTemplate?: ServiceQuotaIncreaseRequestInTemplate;
}
export declare const GetServiceQuotaIncreaseRequestFromTemplateResponse: S.Schema<GetServiceQuotaIncreaseRequestFromTemplateResponse>;
export interface ListAWSDefaultServiceQuotasRequest {
    ServiceCode: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListAWSDefaultServiceQuotasRequest: S.Schema<ListAWSDefaultServiceQuotasRequest>;
export type ServiceQuotaListDefinition = ServiceQuota[];
export declare const ServiceQuotaListDefinition: S.$Array<S.Schema<ServiceQuota>>;
export interface ListAWSDefaultServiceQuotasResponse {
    NextToken?: string;
    Quotas?: ServiceQuota[];
}
export declare const ListAWSDefaultServiceQuotasResponse: S.Schema<ListAWSDefaultServiceQuotasResponse>;
export interface ListRequestedServiceQuotaChangeHistoryRequest {
    ServiceCode?: string;
    Status?: RequestStatus;
    NextToken?: string;
    MaxResults?: number;
    QuotaRequestedAtLevel?: AppliedLevelEnum;
}
export declare const ListRequestedServiceQuotaChangeHistoryRequest: S.Schema<ListRequestedServiceQuotaChangeHistoryRequest>;
export type RequestedServiceQuotaChangeHistoryListDefinition = RequestedServiceQuotaChange[];
export declare const RequestedServiceQuotaChangeHistoryListDefinition: S.$Array<S.Schema<RequestedServiceQuotaChange>>;
export interface ListRequestedServiceQuotaChangeHistoryResponse {
    NextToken?: string;
    RequestedQuotas?: RequestedServiceQuotaChange[];
}
export declare const ListRequestedServiceQuotaChangeHistoryResponse: S.Schema<ListRequestedServiceQuotaChangeHistoryResponse>;
export interface ListRequestedServiceQuotaChangeHistoryByQuotaRequest {
    ServiceCode: string;
    QuotaCode: string;
    Status?: RequestStatus;
    NextToken?: string;
    MaxResults?: number;
    QuotaRequestedAtLevel?: AppliedLevelEnum;
}
export declare const ListRequestedServiceQuotaChangeHistoryByQuotaRequest: S.Schema<ListRequestedServiceQuotaChangeHistoryByQuotaRequest>;
export interface ListRequestedServiceQuotaChangeHistoryByQuotaResponse {
    NextToken?: string;
    RequestedQuotas?: RequestedServiceQuotaChange[];
}
export declare const ListRequestedServiceQuotaChangeHistoryByQuotaResponse: S.Schema<ListRequestedServiceQuotaChangeHistoryByQuotaResponse>;
export interface ListServiceQuotaIncreaseRequestsInTemplateRequest {
    ServiceCode?: string;
    AwsRegion?: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListServiceQuotaIncreaseRequestsInTemplateRequest: S.Schema<ListServiceQuotaIncreaseRequestsInTemplateRequest>;
export type ServiceQuotaIncreaseRequestInTemplateList = ServiceQuotaIncreaseRequestInTemplate[];
export declare const ServiceQuotaIncreaseRequestInTemplateList: S.$Array<S.Schema<ServiceQuotaIncreaseRequestInTemplate>>;
export interface ListServiceQuotaIncreaseRequestsInTemplateResponse {
    ServiceQuotaIncreaseRequestInTemplateList?: ServiceQuotaIncreaseRequestInTemplate[];
    NextToken?: string;
}
export declare const ListServiceQuotaIncreaseRequestsInTemplateResponse: S.Schema<ListServiceQuotaIncreaseRequestsInTemplateResponse>;
export interface ListServiceQuotasRequest {
    ServiceCode: string;
    NextToken?: string;
    MaxResults?: number;
    QuotaCode?: string;
    QuotaAppliedAtLevel?: AppliedLevelEnum;
}
export declare const ListServiceQuotasRequest: S.Schema<ListServiceQuotasRequest>;
export interface ListServiceQuotasResponse {
    NextToken?: string;
    Quotas?: ServiceQuota[];
}
export declare const ListServiceQuotasResponse: S.Schema<ListServiceQuotasResponse>;
export interface ListServicesRequest {
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListServicesRequest: S.Schema<ListServicesRequest>;
export interface ServiceInfo {
    ServiceCode?: string;
    ServiceName?: string;
}
export declare const ServiceInfo: S.Schema<ServiceInfo>;
export type ServiceInfoListDefinition = ServiceInfo[];
export declare const ServiceInfoListDefinition: S.$Array<S.Schema<ServiceInfo>>;
export interface ListServicesResponse {
    NextToken?: string;
    Services?: ServiceInfo[];
}
export declare const ListServicesResponse: S.Schema<ListServicesResponse>;
export interface ListTagsForResourceRequest {
    ResourceARN: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface Tag {
    Key: string;
    Value: string;
}
export declare const Tag: S.Schema<Tag>;
export type OutputTags = Tag[];
export declare const OutputTags: S.$Array<S.Schema<Tag>>;
export interface ListTagsForResourceResponse {
    Tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface PutServiceQuotaIncreaseRequestIntoTemplateRequest {
    QuotaCode: string;
    ServiceCode: string;
    AwsRegion: string;
    DesiredValue: number;
}
export declare const PutServiceQuotaIncreaseRequestIntoTemplateRequest: S.Schema<PutServiceQuotaIncreaseRequestIntoTemplateRequest>;
export interface PutServiceQuotaIncreaseRequestIntoTemplateResponse {
    ServiceQuotaIncreaseRequestInTemplate?: ServiceQuotaIncreaseRequestInTemplate;
}
export declare const PutServiceQuotaIncreaseRequestIntoTemplateResponse: S.Schema<PutServiceQuotaIncreaseRequestIntoTemplateResponse>;
export interface RequestServiceQuotaIncreaseRequest {
    ServiceCode: string;
    QuotaCode: string;
    DesiredValue: number;
    ContextId?: string;
    SupportCaseAllowed?: boolean;
}
export declare const RequestServiceQuotaIncreaseRequest: S.Schema<RequestServiceQuotaIncreaseRequest>;
export interface RequestServiceQuotaIncreaseResponse {
    RequestedQuota?: RequestedServiceQuotaChange;
}
export declare const RequestServiceQuotaIncreaseResponse: S.Schema<RequestServiceQuotaIncreaseResponse>;
export type ExcludedQuotaList = string[];
export declare const ExcludedQuotaList: S.$Array<S.String>;
export type ExclusionList = {
    [key: string]: string[] | undefined;
};
export declare const ExclusionList: S.$Record<S.String, S.optional<S.$Array<S.String>>>;
export interface StartAutoManagementRequest {
    OptInLevel: OptInLevel;
    OptInType: OptInType;
    NotificationArn?: string;
    ExclusionList?: {
        [key: string]: string[] | undefined;
    };
}
export declare const StartAutoManagementRequest: S.Schema<StartAutoManagementRequest>;
export interface StartAutoManagementResponse {
}
export declare const StartAutoManagementResponse: S.Schema<StartAutoManagementResponse>;
export interface StartQuotaUtilizationReportRequest {
}
export declare const StartQuotaUtilizationReportRequest: S.Schema<StartQuotaUtilizationReportRequest>;
export interface StartQuotaUtilizationReportResponse {
    ReportId?: string;
    Status?: ReportStatus;
    Message?: string;
}
export declare const StartQuotaUtilizationReportResponse: S.Schema<StartQuotaUtilizationReportResponse>;
export interface StopAutoManagementRequest {
}
export declare const StopAutoManagementRequest: S.Schema<StopAutoManagementRequest>;
export interface StopAutoManagementResponse {
}
export declare const StopAutoManagementResponse: S.Schema<StopAutoManagementResponse>;
export type InputTags = Tag[];
export declare const InputTags: S.$Array<S.Schema<Tag>>;
export interface TagResourceRequest {
    ResourceARN: string;
    Tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type InputTagKeys = string[];
export declare const InputTagKeys: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceARN: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateAutoManagementRequest {
    OptInType?: OptInType;
    NotificationArn?: string;
    ExclusionList?: {
        [key: string]: string[] | undefined;
    };
}
export declare const UpdateAutoManagementRequest: S.Schema<UpdateAutoManagementRequest>;
export interface UpdateAutoManagementResponse {
}
export declare const UpdateAutoManagementResponse: S.Schema<UpdateAutoManagementResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const AWSServiceAccessNotEnabledException_base: S.Class<AWSServiceAccessNotEnabledException, S.TaggedStruct<"AWSServiceAccessNotEnabledException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AWSServiceAccessNotEnabledException extends AWSServiceAccessNotEnabledException_base {
}
declare const DependencyAccessDeniedException_base: S.Class<DependencyAccessDeniedException, S.TaggedStruct<"DependencyAccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class DependencyAccessDeniedException extends DependencyAccessDeniedException_base {
}
declare const NoAvailableOrganizationException_base: S.Class<NoAvailableOrganizationException, S.TaggedStruct<"NoAvailableOrganizationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class NoAvailableOrganizationException extends NoAvailableOrganizationException_base {
}
declare const OrganizationNotInAllFeaturesModeException_base: S.Class<OrganizationNotInAllFeaturesModeException, S.TaggedStruct<"OrganizationNotInAllFeaturesModeException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class OrganizationNotInAllFeaturesModeException extends OrganizationNotInAllFeaturesModeException_base {
}
declare const ServiceException_base: S.Class<ServiceException, S.TaggedStruct<"ServiceException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class ServiceException extends ServiceException_base {
}
declare const TemplatesNotAvailableInRegionException_base: S.Class<TemplatesNotAvailableInRegionException, S.TaggedStruct<"TemplatesNotAvailableInRegionException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TemplatesNotAvailableInRegionException extends TemplatesNotAvailableInRegionException_base {
}
declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class TooManyRequestsException extends TooManyRequestsException_base {
}
declare const IllegalArgumentException_base: S.Class<IllegalArgumentException, S.TaggedStruct<"IllegalArgumentException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class IllegalArgumentException extends IllegalArgumentException_base {
}
declare const InvalidResourceStateException_base: S.Class<InvalidResourceStateException, S.TaggedStruct<"InvalidResourceStateException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidResourceStateException extends InvalidResourceStateException_base {
}
declare const NoSuchResourceException_base: S.Class<NoSuchResourceException, S.TaggedStruct<"NoSuchResourceException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NoSuchResourceException extends NoSuchResourceException_base {
}
declare const ResourceAlreadyExistsException_base: S.Class<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class ResourceAlreadyExistsException extends ResourceAlreadyExistsException_base {
}
declare const ServiceQuotaTemplateNotInUseException_base: S.Class<ServiceQuotaTemplateNotInUseException, S.TaggedStruct<"ServiceQuotaTemplateNotInUseException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ServiceQuotaTemplateNotInUseException extends ServiceQuotaTemplateNotInUseException_base {
}
declare const InvalidPaginationTokenException_base: S.Class<InvalidPaginationTokenException, S.TaggedStruct<"InvalidPaginationTokenException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidPaginationTokenException extends InvalidPaginationTokenException_base {
}
declare const QuotaExceededException_base: S.Class<QuotaExceededException, S.TaggedStruct<"QuotaExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class QuotaExceededException extends QuotaExceededException_base {
}
declare const TagPolicyViolationException_base: S.Class<TagPolicyViolationException, S.TaggedStruct<"TagPolicyViolationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class TagPolicyViolationException extends TagPolicyViolationException_base {
}
declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TooManyTagsException extends TooManyTagsException_base {
}
export type AssociateServiceQuotaTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | NoAvailableOrganizationException | OrganizationNotInAllFeaturesModeException | ServiceException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Associates your quota request template with your organization. When a new
 * Amazon Web Services account is created in your organization, the quota increase requests in the
 * template are automatically applied to the account. You can add a quota increase request
 * for any adjustable quota to your template.
 */
export declare const associateServiceQuotaTemplate: API.OperationMethod<AssociateServiceQuotaTemplateRequest, AssociateServiceQuotaTemplateResponse, AssociateServiceQuotaTemplateError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSupportCaseError = AccessDeniedException | DependencyAccessDeniedException | IllegalArgumentException | InvalidResourceStateException | NoSuchResourceException | ResourceAlreadyExistsException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Creates a Support case for an existing quota increase request. This call only creates
 * a Support case if the request has a `Pending` status.
 */
export declare const createSupportCase: API.OperationMethod<CreateSupportCaseRequest, CreateSupportCaseResponse, CreateSupportCaseError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteServiceQuotaIncreaseRequestFromTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | IllegalArgumentException | NoAvailableOrganizationException | NoSuchResourceException | ServiceException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Deletes the quota increase request for the specified quota from your quota request
 * template.
 */
export declare const deleteServiceQuotaIncreaseRequestFromTemplate: API.OperationMethod<DeleteServiceQuotaIncreaseRequestFromTemplateRequest, DeleteServiceQuotaIncreaseRequestFromTemplateResponse, DeleteServiceQuotaIncreaseRequestFromTemplateError, Credentials | Region | HttpClient.HttpClient>;
export type DisassociateServiceQuotaTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | NoAvailableOrganizationException | ServiceException | ServiceQuotaTemplateNotInUseException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Disables your quota request template. After a template is disabled, the quota increase
 * requests in the template are not applied to new Amazon Web Services accounts in your organization.
 * Disabling a quota request template does not apply its quota increase requests.
 */
export declare const disassociateServiceQuotaTemplate: API.OperationMethod<DisassociateServiceQuotaTemplateRequest, DisassociateServiceQuotaTemplateResponse, DisassociateServiceQuotaTemplateError, Credentials | Region | HttpClient.HttpClient>;
export type GetAssociationForServiceQuotaTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | NoAvailableOrganizationException | ServiceException | ServiceQuotaTemplateNotInUseException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves the status of the association for the quota request template.
 */
export declare const getAssociationForServiceQuotaTemplate: API.OperationMethod<GetAssociationForServiceQuotaTemplateRequest, GetAssociationForServiceQuotaTemplateResponse, GetAssociationForServiceQuotaTemplateError, Credentials | Region | HttpClient.HttpClient>;
export type GetAutoManagementConfigurationError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves information about your Service Quotas Automatic Management configuration. Automatic Management monitors your Service Quotas utilization and notifies you before you
 * run out of your allocated quotas.
 */
export declare const getAutoManagementConfiguration: API.OperationMethod<GetAutoManagementConfigurationRequest, GetAutoManagementConfigurationResponse, GetAutoManagementConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type GetAWSDefaultServiceQuotaError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves the default value for the specified quota. The default value does not
 * reflect any quota increases.
 */
export declare const getAWSDefaultServiceQuota: API.OperationMethod<GetAWSDefaultServiceQuotaRequest, GetAWSDefaultServiceQuotaResponse, GetAWSDefaultServiceQuotaError, Credentials | Region | HttpClient.HttpClient>;
export type GetQuotaUtilizationReportError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves the quota utilization report for your Amazon Web Services account. This operation returns
 * paginated results showing your quota usage across all Amazon Web Services services, sorted by utilization
 * percentage in descending order (highest utilization first).
 *
 * You must first initiate a report using the `StartQuotaUtilizationReport`
 * operation. The report generation process is asynchronous and may take several seconds to
 * complete. Poll this operation periodically to check the status and retrieve results when
 * the report is ready.
 *
 * Each report contains up to 1,000 quota records per page. Use the `NextToken`
 * parameter to retrieve additional pages of results. Reports are automatically deleted after
 * 15 minutes.
 */
export declare const getQuotaUtilizationReport: API.OperationMethod<GetQuotaUtilizationReportRequest, GetQuotaUtilizationReportResponse, GetQuotaUtilizationReportError, Credentials | Region | HttpClient.HttpClient>;
export type GetRequestedServiceQuotaChangeError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves information about the specified quota increase request.
 */
export declare const getRequestedServiceQuotaChange: API.OperationMethod<GetRequestedServiceQuotaChangeRequest, GetRequestedServiceQuotaChangeResponse, GetRequestedServiceQuotaChangeError, Credentials | Region | HttpClient.HttpClient>;
export type GetServiceQuotaError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves the applied quota value for the specified account-level or resource-level
 * quota. For some quotas, only the default values are available. If the applied quota
 * value is not available for a quota, the quota is not retrieved.
 */
export declare const getServiceQuota: API.OperationMethod<GetServiceQuotaRequest, GetServiceQuotaResponse, GetServiceQuotaError, Credentials | Region | HttpClient.HttpClient>;
export type GetServiceQuotaIncreaseRequestFromTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | IllegalArgumentException | NoAvailableOrganizationException | NoSuchResourceException | ServiceException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves information about the specified quota increase request in your quota request
 * template.
 */
export declare const getServiceQuotaIncreaseRequestFromTemplate: API.OperationMethod<GetServiceQuotaIncreaseRequestFromTemplateRequest, GetServiceQuotaIncreaseRequestFromTemplateResponse, GetServiceQuotaIncreaseRequestFromTemplateError, Credentials | Region | HttpClient.HttpClient>;
export type ListAWSDefaultServiceQuotasError = AccessDeniedException | IllegalArgumentException | InvalidPaginationTokenException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Lists the default values for the quotas for the specified Amazon Web Services service. A default
 * value does not reflect any quota increases.
 */
export declare const listAWSDefaultServiceQuotas: API.OperationMethod<ListAWSDefaultServiceQuotasRequest, ListAWSDefaultServiceQuotasResponse, ListAWSDefaultServiceQuotasError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAWSDefaultServiceQuotasRequest) => stream.Stream<ListAWSDefaultServiceQuotasResponse, ListAWSDefaultServiceQuotasError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAWSDefaultServiceQuotasRequest) => stream.Stream<ServiceQuota, ListAWSDefaultServiceQuotasError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListRequestedServiceQuotaChangeHistoryError = AccessDeniedException | IllegalArgumentException | InvalidPaginationTokenException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves the quota increase requests for the specified Amazon Web Services service. Filter
 * responses to return quota requests at either the account level, resource level, or all
 * levels. Responses include any open or closed requests within 90 days.
 */
export declare const listRequestedServiceQuotaChangeHistory: API.OperationMethod<ListRequestedServiceQuotaChangeHistoryRequest, ListRequestedServiceQuotaChangeHistoryResponse, ListRequestedServiceQuotaChangeHistoryError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRequestedServiceQuotaChangeHistoryRequest) => stream.Stream<ListRequestedServiceQuotaChangeHistoryResponse, ListRequestedServiceQuotaChangeHistoryError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRequestedServiceQuotaChangeHistoryRequest) => stream.Stream<RequestedServiceQuotaChange, ListRequestedServiceQuotaChangeHistoryError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListRequestedServiceQuotaChangeHistoryByQuotaError = AccessDeniedException | IllegalArgumentException | InvalidPaginationTokenException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Retrieves the quota increase requests for the specified quota. Filter responses to
 * return quota requests at either the account level, resource level, or all levels.
 */
export declare const listRequestedServiceQuotaChangeHistoryByQuota: API.OperationMethod<ListRequestedServiceQuotaChangeHistoryByQuotaRequest, ListRequestedServiceQuotaChangeHistoryByQuotaResponse, ListRequestedServiceQuotaChangeHistoryByQuotaError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRequestedServiceQuotaChangeHistoryByQuotaRequest) => stream.Stream<ListRequestedServiceQuotaChangeHistoryByQuotaResponse, ListRequestedServiceQuotaChangeHistoryByQuotaError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRequestedServiceQuotaChangeHistoryByQuotaRequest) => stream.Stream<RequestedServiceQuotaChange, ListRequestedServiceQuotaChangeHistoryByQuotaError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServiceQuotaIncreaseRequestsInTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | IllegalArgumentException | NoAvailableOrganizationException | ServiceException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Lists the quota increase requests in the specified quota request template.
 */
export declare const listServiceQuotaIncreaseRequestsInTemplate: API.OperationMethod<ListServiceQuotaIncreaseRequestsInTemplateRequest, ListServiceQuotaIncreaseRequestsInTemplateResponse, ListServiceQuotaIncreaseRequestsInTemplateError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceQuotaIncreaseRequestsInTemplateRequest) => stream.Stream<ListServiceQuotaIncreaseRequestsInTemplateResponse, ListServiceQuotaIncreaseRequestsInTemplateError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceQuotaIncreaseRequestsInTemplateRequest) => stream.Stream<ServiceQuotaIncreaseRequestInTemplate, ListServiceQuotaIncreaseRequestsInTemplateError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServiceQuotasError = AccessDeniedException | IllegalArgumentException | InvalidPaginationTokenException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Lists the applied quota values for the specified Amazon Web Services service. For some quotas, only
 * the default values are available. If the applied quota value is not available for a
 * quota, the quota is not retrieved. Filter responses to return applied quota values at
 * either the account level, resource level, or all levels.
 */
export declare const listServiceQuotas: API.OperationMethod<ListServiceQuotasRequest, ListServiceQuotasResponse, ListServiceQuotasError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceQuotasRequest) => stream.Stream<ListServiceQuotasResponse, ListServiceQuotasError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceQuotasRequest) => stream.Stream<ServiceQuota, ListServiceQuotasError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServicesError = AccessDeniedException | IllegalArgumentException | InvalidPaginationTokenException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Lists the names and codes for the Amazon Web Services services integrated with Service Quotas.
 */
export declare const listServices: API.OperationMethod<ListServicesRequest, ListServicesResponse, ListServicesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServicesRequest) => stream.Stream<ListServicesResponse, ListServicesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServicesRequest) => stream.Stream<ServiceInfo, ListServicesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Returns a list of the tags assigned to the specified applied quota.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PutServiceQuotaIncreaseRequestIntoTemplateError = AccessDeniedException | AWSServiceAccessNotEnabledException | DependencyAccessDeniedException | IllegalArgumentException | NoAvailableOrganizationException | NoSuchResourceException | QuotaExceededException | ServiceException | TemplatesNotAvailableInRegionException | TooManyRequestsException | CommonErrors;
/**
 * Adds a quota increase request to your quota request template.
 */
export declare const putServiceQuotaIncreaseRequestIntoTemplate: API.OperationMethod<PutServiceQuotaIncreaseRequestIntoTemplateRequest, PutServiceQuotaIncreaseRequestIntoTemplateResponse, PutServiceQuotaIncreaseRequestIntoTemplateError, Credentials | Region | HttpClient.HttpClient>;
export type RequestServiceQuotaIncreaseError = AccessDeniedException | DependencyAccessDeniedException | IllegalArgumentException | InvalidResourceStateException | NoSuchResourceException | QuotaExceededException | ResourceAlreadyExistsException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Submits a quota increase request for the specified quota at the account or resource
 * level.
 */
export declare const requestServiceQuotaIncrease: API.OperationMethod<RequestServiceQuotaIncreaseRequest, RequestServiceQuotaIncreaseResponse, RequestServiceQuotaIncreaseError, Credentials | Region | HttpClient.HttpClient>;
export type StartAutoManagementError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Starts Service Quotas Automatic Management for an Amazon Web Services account, including notification preferences
 * and excluded quotas configurations. Automatic Management monitors your Service Quotas utilization and notifies you before you
 * run out of your allocated quotas.
 */
export declare const startAutoManagement: API.OperationMethod<StartAutoManagementRequest, StartAutoManagementResponse, StartAutoManagementError, Credentials | Region | HttpClient.HttpClient>;
export type StartQuotaUtilizationReportError = AccessDeniedException | IllegalArgumentException | InvalidPaginationTokenException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Initiates the generation of a quota utilization report for your Amazon Web Services account. This
 * asynchronous operation analyzes your quota usage across all Amazon Web Services services and returns
 * a unique report identifier that you can use to retrieve the results.
 *
 * The report generation process may take several seconds to complete, depending on the
 * number of quotas in your account. Use the `GetQuotaUtilizationReport` operation
 * to check the status and retrieve the results when the report is ready.
 */
export declare const startQuotaUtilizationReport: API.OperationMethod<StartQuotaUtilizationReportRequest, StartQuotaUtilizationReportResponse, StartQuotaUtilizationReportError, Credentials | Region | HttpClient.HttpClient>;
export type StopAutoManagementError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Stops Service Quotas Automatic Management for an Amazon Web Services account and removes all associated
 * configurations. Automatic Management monitors your Service Quotas utilization and notifies you before you
 * run out of your allocated quotas.
 */
export declare const stopAutoManagement: API.OperationMethod<StopAutoManagementRequest, StopAutoManagementResponse, StopAutoManagementError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TagPolicyViolationException | TooManyRequestsException | TooManyTagsException | CommonErrors;
/**
 * Adds tags to the specified applied quota. You can include one or more tags to add to
 * the quota.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Removes tags from the specified applied quota. You can specify one or more tags to
 * remove.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateAutoManagementError = AccessDeniedException | IllegalArgumentException | NoSuchResourceException | ServiceException | TooManyRequestsException | CommonErrors;
/**
 * Updates your Service Quotas Automatic Management configuration, including notification preferences and
 * excluded quotas. Automatic Management monitors your Service Quotas utilization and notifies you before you
 * run out of your allocated quotas.
 */
export declare const updateAutoManagement: API.OperationMethod<UpdateAutoManagementRequest, UpdateAutoManagementResponse, UpdateAutoManagementError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=service-quotas.d.ts.map