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 Directory = string;
export type IpV4 = string;
export type IpV6 = string;
export type Subnet = string;
export type ActiveDirectoryType = string;
export type Arn = string;
export type ServerType = string;
export type LicenseServerEndpointId = string;
export type LicenseServerEndpointProvisioningStatus = string;
export type LicenseServerHealthStatus = string;
export type SecurityGroup = string;
export type BoxInteger = number;
export type ResourceArn = string;
export type IpV4List = string[];
export declare const IpV4List: S.$Array<S.String>;
export type IpV6List = string[];
export declare const IpV6List: S.$Array<S.String>;
export interface SecretsManagerCredentialsProvider {
    SecretId?: string;
}
export declare const SecretsManagerCredentialsProvider: S.Schema<SecretsManagerCredentialsProvider>;
export type CredentialsProvider = {
    SecretsManagerCredentialsProvider: SecretsManagerCredentialsProvider;
};
export declare const CredentialsProvider: S.Union<readonly [S.Struct<{
    readonly SecretsManagerCredentialsProvider: S.Schema<SecretsManagerCredentialsProvider>;
}>]>;
export type Subnets = string[];
export declare const Subnets: S.$Array<S.String>;
export interface DomainNetworkSettings {
    Subnets: string[];
}
export declare const DomainNetworkSettings: S.Schema<DomainNetworkSettings>;
export interface ActiveDirectorySettings {
    DomainName?: string;
    DomainIpv4List?: string[];
    DomainIpv6List?: string[];
    DomainCredentialsProvider?: CredentialsProvider;
    DomainNetworkSettings?: DomainNetworkSettings;
}
export declare const ActiveDirectorySettings: S.Schema<ActiveDirectorySettings>;
export interface ActiveDirectoryIdentityProvider {
    DirectoryId?: string;
    ActiveDirectorySettings?: ActiveDirectorySettings;
    ActiveDirectoryType?: string;
    IsSharedActiveDirectory?: boolean;
}
export declare const ActiveDirectoryIdentityProvider: S.Schema<ActiveDirectoryIdentityProvider>;
export type IdentityProvider = {
    ActiveDirectoryIdentityProvider: ActiveDirectoryIdentityProvider;
};
export declare const IdentityProvider: S.Union<readonly [S.Struct<{
    readonly ActiveDirectoryIdentityProvider: S.Schema<ActiveDirectoryIdentityProvider>;
}>]>;
export type Tags = {
    [key: string]: string | undefined;
};
export declare const Tags: S.$Record<S.String, S.optional<S.String>>;
export interface AssociateUserRequest {
    Username: string;
    InstanceId: string;
    IdentityProvider: IdentityProvider;
    Domain?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const AssociateUserRequest: S.Schema<AssociateUserRequest>;
export interface InstanceUserSummary {
    Username: string;
    InstanceId: string;
    IdentityProvider: IdentityProvider;
    Status: string;
    InstanceUserArn?: string;
    StatusMessage?: string;
    Domain?: string;
    AssociationDate?: string;
    DisassociationDate?: string;
}
export declare const InstanceUserSummary: S.Schema<InstanceUserSummary>;
export interface AssociateUserResponse {
    InstanceUserSummary: InstanceUserSummary;
}
export declare const AssociateUserResponse: S.Schema<AssociateUserResponse>;
export interface RdsSalSettings {
    RdsSalCredentialsProvider: CredentialsProvider;
}
export declare const RdsSalSettings: S.Schema<RdsSalSettings>;
export type ServerSettings = {
    RdsSalSettings: RdsSalSettings;
};
export declare const ServerSettings: S.Union<readonly [S.Struct<{
    readonly RdsSalSettings: S.Schema<RdsSalSettings>;
}>]>;
export interface LicenseServerSettings {
    ServerType: string;
    ServerSettings: ServerSettings;
}
export declare const LicenseServerSettings: S.Schema<LicenseServerSettings>;
export interface CreateLicenseServerEndpointRequest {
    IdentityProviderArn: string;
    LicenseServerSettings: LicenseServerSettings;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateLicenseServerEndpointRequest: S.Schema<CreateLicenseServerEndpointRequest>;
export interface CreateLicenseServerEndpointResponse {
    IdentityProviderArn?: string;
    LicenseServerEndpointArn?: string;
}
export declare const CreateLicenseServerEndpointResponse: S.Schema<CreateLicenseServerEndpointResponse>;
export interface DeleteLicenseServerEndpointRequest {
    LicenseServerEndpointArn: string;
    ServerType: string;
}
export declare const DeleteLicenseServerEndpointRequest: S.Schema<DeleteLicenseServerEndpointRequest>;
export interface ServerEndpoint {
    Endpoint?: string;
}
export declare const ServerEndpoint: S.Schema<ServerEndpoint>;
export interface LicenseServer {
    ProvisioningStatus?: string;
    HealthStatus?: string;
    Ipv4Address?: string;
    Ipv6Address?: string;
}
export declare const LicenseServer: S.Schema<LicenseServer>;
export type LicenseServerList = LicenseServer[];
export declare const LicenseServerList: S.$Array<S.Schema<LicenseServer>>;
export interface LicenseServerEndpoint {
    IdentityProviderArn?: string;
    ServerType?: string;
    ServerEndpoint?: ServerEndpoint;
    StatusMessage?: string;
    LicenseServerEndpointId?: string;
    LicenseServerEndpointArn?: string;
    LicenseServerEndpointProvisioningStatus?: string;
    LicenseServers?: LicenseServer[];
    CreationTime?: Date;
}
export declare const LicenseServerEndpoint: S.Schema<LicenseServerEndpoint>;
export interface DeleteLicenseServerEndpointResponse {
    LicenseServerEndpoint?: LicenseServerEndpoint;
}
export declare const DeleteLicenseServerEndpointResponse: S.Schema<DeleteLicenseServerEndpointResponse>;
export interface DeregisterIdentityProviderRequest {
    IdentityProvider?: IdentityProvider;
    Product?: string;
    IdentityProviderArn?: string;
}
export declare const DeregisterIdentityProviderRequest: S.Schema<DeregisterIdentityProviderRequest>;
export interface Settings {
    Subnets: string[];
    SecurityGroupId: string;
}
export declare const Settings: S.Schema<Settings>;
export interface IdentityProviderSummary {
    IdentityProvider: IdentityProvider;
    Settings: Settings;
    Product: string;
    Status: string;
    IdentityProviderArn?: string;
    FailureMessage?: string;
    OwnerAccountId?: string;
}
export declare const IdentityProviderSummary: S.Schema<IdentityProviderSummary>;
export interface DeregisterIdentityProviderResponse {
    IdentityProviderSummary: IdentityProviderSummary;
}
export declare const DeregisterIdentityProviderResponse: S.Schema<DeregisterIdentityProviderResponse>;
export interface DisassociateUserRequest {
    Username?: string;
    InstanceId?: string;
    IdentityProvider?: IdentityProvider;
    InstanceUserArn?: string;
    Domain?: string;
}
export declare const DisassociateUserRequest: S.Schema<DisassociateUserRequest>;
export interface DisassociateUserResponse {
    InstanceUserSummary: InstanceUserSummary;
}
export declare const DisassociateUserResponse: S.Schema<DisassociateUserResponse>;
export interface Filter {
    Attribute?: string;
    Operation?: string;
    Value?: string;
}
export declare const Filter: S.Schema<Filter>;
export type FilterList = Filter[];
export declare const FilterList: S.$Array<S.Schema<Filter>>;
export interface ListIdentityProvidersRequest {
    MaxResults?: number;
    Filters?: Filter[];
    NextToken?: string;
}
export declare const ListIdentityProvidersRequest: S.Schema<ListIdentityProvidersRequest>;
export type IdentityProviderSummaryList = IdentityProviderSummary[];
export declare const IdentityProviderSummaryList: S.$Array<S.Schema<IdentityProviderSummary>>;
export interface ListIdentityProvidersResponse {
    IdentityProviderSummaries: IdentityProviderSummary[];
    NextToken?: string;
}
export declare const ListIdentityProvidersResponse: S.Schema<ListIdentityProvidersResponse>;
export interface ListInstancesRequest {
    MaxResults?: number;
    NextToken?: string;
    Filters?: Filter[];
}
export declare const ListInstancesRequest: S.Schema<ListInstancesRequest>;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export interface InstanceSummary {
    InstanceId: string;
    Status: string;
    Products: string[];
    LastStatusCheckDate?: string;
    StatusMessage?: string;
    OwnerAccountId?: string;
    IdentityProvider?: IdentityProvider;
}
export declare const InstanceSummary: S.Schema<InstanceSummary>;
export type InstanceSummaryList = InstanceSummary[];
export declare const InstanceSummaryList: S.$Array<S.Schema<InstanceSummary>>;
export interface ListInstancesResponse {
    InstanceSummaries?: InstanceSummary[];
    NextToken?: string;
}
export declare const ListInstancesResponse: S.Schema<ListInstancesResponse>;
export interface ListLicenseServerEndpointsRequest {
    MaxResults?: number;
    Filters?: Filter[];
    NextToken?: string;
}
export declare const ListLicenseServerEndpointsRequest: S.Schema<ListLicenseServerEndpointsRequest>;
export type LicenseServerEndpointList = LicenseServerEndpoint[];
export declare const LicenseServerEndpointList: S.$Array<S.Schema<LicenseServerEndpoint>>;
export interface ListLicenseServerEndpointsResponse {
    LicenseServerEndpoints?: LicenseServerEndpoint[];
    NextToken?: string;
}
export declare const ListLicenseServerEndpointsResponse: S.Schema<ListLicenseServerEndpointsResponse>;
export interface ListProductSubscriptionsRequest {
    Product?: string;
    IdentityProvider: IdentityProvider;
    MaxResults?: number;
    Filters?: Filter[];
    NextToken?: string;
}
export declare const ListProductSubscriptionsRequest: S.Schema<ListProductSubscriptionsRequest>;
export interface ProductUserSummary {
    Username: string;
    Product: string;
    IdentityProvider: IdentityProvider;
    Status: string;
    ProductUserArn?: string;
    StatusMessage?: string;
    Domain?: string;
    SubscriptionStartDate?: string;
    SubscriptionEndDate?: string;
}
export declare const ProductUserSummary: S.Schema<ProductUserSummary>;
export type ProductUserSummaryList = ProductUserSummary[];
export declare const ProductUserSummaryList: S.$Array<S.Schema<ProductUserSummary>>;
export interface ListProductSubscriptionsResponse {
    ProductUserSummaries?: ProductUserSummary[];
    NextToken?: string;
}
export declare const ListProductSubscriptionsResponse: S.Schema<ListProductSubscriptionsResponse>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface ListUserAssociationsRequest {
    InstanceId: string;
    IdentityProvider: IdentityProvider;
    MaxResults?: number;
    Filters?: Filter[];
    NextToken?: string;
}
export declare const ListUserAssociationsRequest: S.Schema<ListUserAssociationsRequest>;
export type InstanceUserSummaryList = InstanceUserSummary[];
export declare const InstanceUserSummaryList: S.$Array<S.Schema<InstanceUserSummary>>;
export interface ListUserAssociationsResponse {
    InstanceUserSummaries?: InstanceUserSummary[];
    NextToken?: string;
}
export declare const ListUserAssociationsResponse: S.Schema<ListUserAssociationsResponse>;
export interface RegisterIdentityProviderRequest {
    IdentityProvider: IdentityProvider;
    Product: string;
    Settings?: Settings;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const RegisterIdentityProviderRequest: S.Schema<RegisterIdentityProviderRequest>;
export interface RegisterIdentityProviderResponse {
    IdentityProviderSummary: IdentityProviderSummary;
}
export declare const RegisterIdentityProviderResponse: S.Schema<RegisterIdentityProviderResponse>;
export interface StartProductSubscriptionRequest {
    Username: string;
    IdentityProvider: IdentityProvider;
    Product: string;
    Domain?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const StartProductSubscriptionRequest: S.Schema<StartProductSubscriptionRequest>;
export interface StartProductSubscriptionResponse {
    ProductUserSummary: ProductUserSummary;
}
export declare const StartProductSubscriptionResponse: S.Schema<StartProductSubscriptionResponse>;
export interface StopProductSubscriptionRequest {
    Username?: string;
    IdentityProvider?: IdentityProvider;
    Product?: string;
    ProductUserArn?: string;
    Domain?: string;
}
export declare const StopProductSubscriptionRequest: S.Schema<StopProductSubscriptionRequest>;
export interface StopProductSubscriptionResponse {
    ProductUserSummary: ProductUserSummary;
}
export declare const StopProductSubscriptionResponse: S.Schema<StopProductSubscriptionResponse>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: 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 UpdateSettings {
    AddSubnets: string[];
    RemoveSubnets: string[];
    SecurityGroupId?: string;
}
export declare const UpdateSettings: S.Schema<UpdateSettings>;
export interface UpdateIdentityProviderSettingsRequest {
    IdentityProvider?: IdentityProvider;
    Product?: string;
    IdentityProviderArn?: string;
    UpdateSettings: UpdateSettings;
}
export declare const UpdateIdentityProviderSettingsRequest: S.Schema<UpdateIdentityProviderSettingsRequest>;
export interface UpdateIdentityProviderSettingsResponse {
    IdentityProviderSummary: IdentityProviderSummary;
}
export declare const UpdateIdentityProviderSettingsResponse: S.Schema<UpdateIdentityProviderSettingsResponse>;
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 ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ConflictException extends ConflictException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class ValidationException extends ValidationException_base {
}
export type AssociateUserError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Associates the user to an EC2 instance to utilize user-based subscriptions.
 *
 * Your estimated bill for charges on the number of users and related costs will take 48 hours to appear for billing periods that haven't closed (marked as **Pending** billing status) in Amazon Web Services Billing. For more information, see Viewing your monthly charges in the *Amazon Web Services Billing User Guide*.
 */
export declare const associateUser: API.OperationMethod<AssociateUserRequest, AssociateUserResponse, AssociateUserError, Credentials | Region | HttpClient.HttpClient>;
export type CreateLicenseServerEndpointError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a network endpoint for the Remote Desktop Services (RDS) license server.
 */
export declare const createLicenseServerEndpoint: API.OperationMethod<CreateLicenseServerEndpointRequest, CreateLicenseServerEndpointResponse, CreateLicenseServerEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteLicenseServerEndpointError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a `LicenseServerEndpoint` resource.
 */
export declare const deleteLicenseServerEndpoint: API.OperationMethod<DeleteLicenseServerEndpointRequest, DeleteLicenseServerEndpointResponse, DeleteLicenseServerEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type DeregisterIdentityProviderError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deregisters the Active Directory identity provider from License Manager user-based subscriptions.
 */
export declare const deregisterIdentityProvider: API.OperationMethod<DeregisterIdentityProviderRequest, DeregisterIdentityProviderResponse, DeregisterIdentityProviderError, Credentials | Region | HttpClient.HttpClient>;
export type DisassociateUserError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Disassociates the user from an EC2 instance providing user-based subscriptions.
 */
export declare const disassociateUser: API.OperationMethod<DisassociateUserRequest, DisassociateUserResponse, DisassociateUserError, Credentials | Region | HttpClient.HttpClient>;
export type ListIdentityProvidersError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the Active Directory identity providers for user-based subscriptions.
 */
export declare const listIdentityProviders: API.OperationMethod<ListIdentityProvidersRequest, ListIdentityProvidersResponse, ListIdentityProvidersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListIdentityProvidersRequest) => stream.Stream<ListIdentityProvidersResponse, ListIdentityProvidersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListIdentityProvidersRequest) => stream.Stream<IdentityProviderSummary, ListIdentityProvidersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListInstancesError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the EC2 instances providing user-based subscriptions.
 */
export declare const listInstances: API.OperationMethod<ListInstancesRequest, ListInstancesResponse, ListInstancesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListInstancesRequest) => stream.Stream<ListInstancesResponse, ListInstancesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListInstancesRequest) => stream.Stream<InstanceSummary, ListInstancesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListLicenseServerEndpointsError = AccessDeniedException | ConflictException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List the Remote Desktop Services (RDS) License Server endpoints
 */
export declare const listLicenseServerEndpoints: API.OperationMethod<ListLicenseServerEndpointsRequest, ListLicenseServerEndpointsResponse, ListLicenseServerEndpointsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListLicenseServerEndpointsRequest) => stream.Stream<ListLicenseServerEndpointsResponse, ListLicenseServerEndpointsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListLicenseServerEndpointsRequest) => stream.Stream<LicenseServerEndpoint, ListLicenseServerEndpointsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListProductSubscriptionsError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the user-based subscription products available from an identity provider.
 */
export declare const listProductSubscriptions: API.OperationMethod<ListProductSubscriptionsRequest, ListProductSubscriptionsResponse, ListProductSubscriptionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListProductSubscriptionsRequest) => stream.Stream<ListProductSubscriptionsResponse, ListProductSubscriptionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListProductSubscriptionsRequest) => stream.Stream<ProductUserSummary, ListProductSubscriptionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns the list of tags for the specified resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type ListUserAssociationsError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists user associations for an identity provider.
 */
export declare const listUserAssociations: API.OperationMethod<ListUserAssociationsRequest, ListUserAssociationsResponse, ListUserAssociationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListUserAssociationsRequest) => stream.Stream<ListUserAssociationsResponse, ListUserAssociationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListUserAssociationsRequest) => stream.Stream<InstanceUserSummary, ListUserAssociationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type RegisterIdentityProviderError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Registers an identity provider for user-based subscriptions.
 */
export declare const registerIdentityProvider: API.OperationMethod<RegisterIdentityProviderRequest, RegisterIdentityProviderResponse, RegisterIdentityProviderError, Credentials | Region | HttpClient.HttpClient>;
export type StartProductSubscriptionError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Starts a product subscription for a user with the specified identity provider.
 *
 * Your estimated bill for charges on the number of users and related costs will take 48 hours to appear for billing periods that haven't closed (marked as **Pending** billing status) in Amazon Web Services Billing. For more information, see Viewing your monthly charges in the *Amazon Web Services Billing User Guide*.
 */
export declare const startProductSubscription: API.OperationMethod<StartProductSubscriptionRequest, StartProductSubscriptionResponse, StartProductSubscriptionError, Credentials | Region | HttpClient.HttpClient>;
export type StopProductSubscriptionError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Stops a product subscription for a user with the specified identity provider.
 */
export declare const stopProductSubscription: API.OperationMethod<StopProductSubscriptionRequest, StopProductSubscriptionResponse, StopProductSubscriptionError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Adds tags to a resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Removes tags from a resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateIdentityProviderSettingsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates additional product configuration settings for the registered identity provider.
 */
export declare const updateIdentityProviderSettings: API.OperationMethod<UpdateIdentityProviderSettingsRequest, UpdateIdentityProviderSettingsResponse, UpdateIdentityProviderSettingsError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=license-manager-user-subscriptions.d.ts.map