import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
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 NetworkId = string;
export type SensitiveString = string | redacted.Redacted<string>;
export type SecurityGroupId = string;
export type ClientToken = string;
export type UserId = string;
export type Uname = string;
export type BotId = string;
export type SecurityGroupIdList = string[];
export declare const SecurityGroupIdList: S.$Array<S.String>;
export interface BatchCreateUserRequestItem {
    firstName?: string | redacted.Redacted<string>;
    lastName?: string | redacted.Redacted<string>;
    securityGroupIds: string[];
    username: string;
    inviteCode?: string;
    inviteCodeTtl?: number;
    codeValidation?: boolean;
}
export declare const BatchCreateUserRequestItem: S.Schema<BatchCreateUserRequestItem>;
export type BatchCreateUserRequestItems = BatchCreateUserRequestItem[];
export declare const BatchCreateUserRequestItems: S.$Array<S.Schema<BatchCreateUserRequestItem>>;
export interface BatchCreateUserRequest {
    networkId: string;
    users: BatchCreateUserRequestItem[];
    clientToken?: string;
}
export declare const BatchCreateUserRequest: S.Schema<BatchCreateUserRequest>;
export interface User {
    userId?: string;
    firstName?: string | redacted.Redacted<string>;
    lastName?: string | redacted.Redacted<string>;
    username?: string;
    securityGroups?: string[];
    isAdmin?: boolean;
    suspended?: boolean;
    status?: number;
    otpEnabled?: boolean;
    scimId?: string;
    type?: string;
    cell?: string;
    countryCode?: string;
    challengeFailures?: number;
    isInviteExpired?: boolean;
    isUser?: boolean;
    inviteCode?: string;
    codeValidation?: boolean;
    uname?: string;
}
export declare const User: S.Schema<User>;
export type Users = User[];
export declare const Users: S.$Array<S.Schema<User>>;
export interface BatchUserErrorResponseItem {
    field?: string;
    reason?: string;
    userId: string;
}
export declare const BatchUserErrorResponseItem: S.Schema<BatchUserErrorResponseItem>;
export type BatchUserErrorResponseItems = BatchUserErrorResponseItem[];
export declare const BatchUserErrorResponseItems: S.$Array<S.Schema<BatchUserErrorResponseItem>>;
export interface BatchCreateUserResponse {
    message?: string;
    successful?: User[];
    failed?: BatchUserErrorResponseItem[];
}
export declare const BatchCreateUserResponse: S.Schema<BatchCreateUserResponse>;
export interface ErrorDetail {
    field?: string;
    reason?: string;
}
export declare const ErrorDetail: S.Schema<ErrorDetail>;
export type ErrorDetailList = ErrorDetail[];
export declare const ErrorDetailList: S.$Array<S.Schema<ErrorDetail>>;
export type UserIds = string[];
export declare const UserIds: S.$Array<S.String>;
export interface BatchDeleteUserRequest {
    networkId: string;
    userIds: string[];
    clientToken?: string;
}
export declare const BatchDeleteUserRequest: S.Schema<BatchDeleteUserRequest>;
export interface BatchUserSuccessResponseItem {
    userId: string;
}
export declare const BatchUserSuccessResponseItem: S.Schema<BatchUserSuccessResponseItem>;
export type BatchUserSuccessResponseItems = BatchUserSuccessResponseItem[];
export declare const BatchUserSuccessResponseItems: S.$Array<S.Schema<BatchUserSuccessResponseItem>>;
export interface BatchDeleteUserResponse {
    message?: string;
    successful?: BatchUserSuccessResponseItem[];
    failed?: BatchUserErrorResponseItem[];
}
export declare const BatchDeleteUserResponse: S.Schema<BatchDeleteUserResponse>;
export type Unames = string[];
export declare const Unames: S.$Array<S.String>;
export interface BatchLookupUserUnameRequest {
    networkId: string;
    unames: string[];
    clientToken?: string;
}
export declare const BatchLookupUserUnameRequest: S.Schema<BatchLookupUserUnameRequest>;
export interface BatchUnameSuccessResponseItem {
    uname: string;
    username: string;
}
export declare const BatchUnameSuccessResponseItem: S.Schema<BatchUnameSuccessResponseItem>;
export type BatchUnameSuccessResponseItems = BatchUnameSuccessResponseItem[];
export declare const BatchUnameSuccessResponseItems: S.$Array<S.Schema<BatchUnameSuccessResponseItem>>;
export interface BatchUnameErrorResponseItem {
    field?: string;
    reason?: string;
    uname: string;
}
export declare const BatchUnameErrorResponseItem: S.Schema<BatchUnameErrorResponseItem>;
export type BatchUnameErrorResponseItems = BatchUnameErrorResponseItem[];
export declare const BatchUnameErrorResponseItems: S.$Array<S.Schema<BatchUnameErrorResponseItem>>;
export interface BatchLookupUserUnameResponse {
    message?: string;
    successful?: BatchUnameSuccessResponseItem[];
    failed?: BatchUnameErrorResponseItem[];
}
export declare const BatchLookupUserUnameResponse: S.Schema<BatchLookupUserUnameResponse>;
export interface BatchReinviteUserRequest {
    networkId: string;
    userIds: string[];
    clientToken?: string;
}
export declare const BatchReinviteUserRequest: S.Schema<BatchReinviteUserRequest>;
export interface BatchReinviteUserResponse {
    message?: string;
    successful?: BatchUserSuccessResponseItem[];
    failed?: BatchUserErrorResponseItem[];
}
export declare const BatchReinviteUserResponse: S.Schema<BatchReinviteUserResponse>;
export type AppIds = string[];
export declare const AppIds: S.$Array<S.String>;
export interface BatchResetDevicesForUserRequest {
    networkId: string;
    userId: string;
    appIds: string[];
    clientToken?: string;
}
export declare const BatchResetDevicesForUserRequest: S.Schema<BatchResetDevicesForUserRequest>;
export interface BatchDeviceSuccessResponseItem {
    appId: string;
}
export declare const BatchDeviceSuccessResponseItem: S.Schema<BatchDeviceSuccessResponseItem>;
export type BatchDeviceSuccessResponseItems = BatchDeviceSuccessResponseItem[];
export declare const BatchDeviceSuccessResponseItems: S.$Array<S.Schema<BatchDeviceSuccessResponseItem>>;
export interface BatchDeviceErrorResponseItem {
    field?: string;
    reason?: string;
    appId: string;
}
export declare const BatchDeviceErrorResponseItem: S.Schema<BatchDeviceErrorResponseItem>;
export type BatchDeviceErrorResponseItems = BatchDeviceErrorResponseItem[];
export declare const BatchDeviceErrorResponseItems: S.$Array<S.Schema<BatchDeviceErrorResponseItem>>;
export interface BatchResetDevicesForUserResponse {
    message?: string;
    successful?: BatchDeviceSuccessResponseItem[];
    failed?: BatchDeviceErrorResponseItem[];
}
export declare const BatchResetDevicesForUserResponse: S.Schema<BatchResetDevicesForUserResponse>;
export interface BatchToggleUserSuspendStatusRequest {
    networkId: string;
    suspend: boolean;
    userIds: string[];
    clientToken?: string;
}
export declare const BatchToggleUserSuspendStatusRequest: S.Schema<BatchToggleUserSuspendStatusRequest>;
export interface BatchToggleUserSuspendStatusResponse {
    message?: string;
    successful?: BatchUserSuccessResponseItem[];
    failed?: BatchUserErrorResponseItem[];
}
export declare const BatchToggleUserSuspendStatusResponse: S.Schema<BatchToggleUserSuspendStatusResponse>;
export interface CreateBotRequest {
    networkId: string;
    username: string;
    displayName?: string;
    groupId: string;
    challenge: string | redacted.Redacted<string>;
}
export declare const CreateBotRequest: S.Schema<CreateBotRequest>;
export interface CreateBotResponse {
    message?: string;
    botId: string;
    networkId?: string;
    username?: string;
    displayName?: string;
    groupId?: string;
}
export declare const CreateBotResponse: S.Schema<CreateBotResponse>;
export interface CreateDataRetentionBotRequest {
    networkId: string;
}
export declare const CreateDataRetentionBotRequest: S.Schema<CreateDataRetentionBotRequest>;
export interface CreateDataRetentionBotResponse {
    message?: string;
}
export declare const CreateDataRetentionBotResponse: S.Schema<CreateDataRetentionBotResponse>;
export interface CreateDataRetentionBotChallengeRequest {
    networkId: string;
}
export declare const CreateDataRetentionBotChallengeRequest: S.Schema<CreateDataRetentionBotChallengeRequest>;
export interface CreateDataRetentionBotChallengeResponse {
    challenge: string | redacted.Redacted<string>;
}
export declare const CreateDataRetentionBotChallengeResponse: S.Schema<CreateDataRetentionBotChallengeResponse>;
export type AccessLevel = "STANDARD" | "PREMIUM" | (string & {});
export declare const AccessLevel: S.String;
export interface CreateNetworkRequest {
    networkName: string;
    accessLevel: AccessLevel;
    enablePremiumFreeTrial?: boolean;
    encryptionKeyArn?: string;
}
export declare const CreateNetworkRequest: S.Schema<CreateNetworkRequest>;
export interface CreateNetworkResponse {
    networkId?: string;
    networkName?: string;
    encryptionKeyArn?: string;
}
export declare const CreateNetworkResponse: S.Schema<CreateNetworkResponse>;
export type PermittedNetworksList = string[];
export declare const PermittedNetworksList: S.$Array<S.String>;
export interface WickrAwsNetworks {
    region: string;
    networkId: string;
}
export declare const WickrAwsNetworks: S.Schema<WickrAwsNetworks>;
export type WickrAwsNetworksList = WickrAwsNetworks[];
export declare const WickrAwsNetworksList: S.$Array<S.Schema<WickrAwsNetworks>>;
export interface PermittedWickrEnterpriseNetwork {
    domain: string;
    networkId: string;
}
export declare const PermittedWickrEnterpriseNetwork: S.Schema<PermittedWickrEnterpriseNetwork>;
export type PermittedWickrEnterpriseNetworksList = PermittedWickrEnterpriseNetwork[];
export declare const PermittedWickrEnterpriseNetworksList: S.$Array<S.Schema<PermittedWickrEnterpriseNetwork>>;
export interface SecurityGroupSettingsRequest {
    lockoutThreshold?: number;
    permittedNetworks?: string[];
    enableGuestFederation?: boolean;
    globalFederation?: boolean;
    federationMode?: number;
    enableRestrictedGlobalFederation?: boolean;
    permittedWickrAwsNetworks?: WickrAwsNetworks[];
    permittedWickrEnterpriseNetworks?: PermittedWickrEnterpriseNetwork[];
}
export declare const SecurityGroupSettingsRequest: S.Schema<SecurityGroupSettingsRequest>;
export interface CreateSecurityGroupRequest {
    networkId: string;
    name: string;
    securityGroupSettings: SecurityGroupSettingsRequest;
    clientToken?: string;
}
export declare const CreateSecurityGroupRequest: S.Schema<CreateSecurityGroupRequest>;
export type SecurityGroupStringList = string[];
export declare const SecurityGroupStringList: S.$Array<S.String>;
export interface CallingSettings {
    canStart11Call?: boolean;
    canVideoCall?: boolean;
    forceTcpCall?: boolean;
}
export declare const CallingSettings: S.Schema<CallingSettings>;
export interface PasswordRequirements {
    lowercase?: number;
    minLength?: number;
    numbers?: number;
    symbols?: number;
    uppercase?: number;
}
export declare const PasswordRequirements: S.Schema<PasswordRequirements>;
export interface ShredderSettings {
    canProcessManually?: boolean;
    intensity?: number;
}
export declare const ShredderSettings: S.Schema<ShredderSettings>;
export interface SecurityGroupSettings {
    alwaysReauthenticate?: boolean;
    atakPackageValues?: string[];
    calling?: CallingSettings;
    checkForUpdates?: boolean;
    enableAtak?: boolean;
    enableCrashReports?: boolean;
    enableFileDownload?: boolean;
    enableGuestFederation?: boolean;
    enableNotificationPreview?: boolean;
    enableOpenAccessOption?: boolean;
    enableRestrictedGlobalFederation?: boolean;
    filesEnabled?: boolean;
    forceDeviceLockout?: number;
    forceOpenAccess?: boolean;
    forceReadReceipts?: boolean;
    globalFederation?: boolean;
    isAtoEnabled?: boolean;
    isLinkPreviewEnabled?: boolean;
    locationAllowMaps?: boolean;
    locationEnabled?: boolean;
    maxAutoDownloadSize?: number;
    maxBor?: number;
    maxTtl?: number;
    messageForwardingEnabled?: boolean;
    passwordRequirements?: PasswordRequirements;
    presenceEnabled?: boolean;
    quickResponses?: string[];
    showMasterRecoveryKey?: boolean;
    shredder?: ShredderSettings;
    ssoMaxIdleMinutes?: number;
    federationMode?: number;
    lockoutThreshold?: number;
    permittedNetworks?: string[];
    permittedWickrAwsNetworks?: WickrAwsNetworks[];
    permittedWickrEnterpriseNetworks?: PermittedWickrEnterpriseNetwork[];
}
export declare const SecurityGroupSettings: S.Schema<SecurityGroupSettings>;
export interface SecurityGroup {
    activeMembers: number;
    botMembers: number;
    activeDirectoryGuid?: string;
    id: string;
    isDefault: boolean;
    name: string;
    modified: number;
    securityGroupSettings: SecurityGroupSettings;
}
export declare const SecurityGroup: S.Schema<SecurityGroup>;
export interface CreateSecurityGroupResponse {
    securityGroup: SecurityGroup;
}
export declare const CreateSecurityGroupResponse: S.Schema<CreateSecurityGroupResponse>;
export interface DeleteBotRequest {
    networkId: string;
    botId: string;
}
export declare const DeleteBotRequest: S.Schema<DeleteBotRequest>;
export interface DeleteBotResponse {
    message?: string;
}
export declare const DeleteBotResponse: S.Schema<DeleteBotResponse>;
export interface DeleteDataRetentionBotRequest {
    networkId: string;
}
export declare const DeleteDataRetentionBotRequest: S.Schema<DeleteDataRetentionBotRequest>;
export interface DeleteDataRetentionBotResponse {
    message?: string;
}
export declare const DeleteDataRetentionBotResponse: S.Schema<DeleteDataRetentionBotResponse>;
export interface DeleteNetworkRequest {
    networkId: string;
    clientToken?: string;
}
export declare const DeleteNetworkRequest: S.Schema<DeleteNetworkRequest>;
export interface DeleteNetworkResponse {
    message?: string;
}
export declare const DeleteNetworkResponse: S.Schema<DeleteNetworkResponse>;
export interface DeleteSecurityGroupRequest {
    networkId: string;
    groupId: string;
}
export declare const DeleteSecurityGroupRequest: S.Schema<DeleteSecurityGroupRequest>;
export interface DeleteSecurityGroupResponse {
    message?: string;
    networkId?: string;
    groupId?: string;
}
export declare const DeleteSecurityGroupResponse: S.Schema<DeleteSecurityGroupResponse>;
export interface GetBotRequest {
    networkId: string;
    botId: string;
}
export declare const GetBotRequest: S.Schema<GetBotRequest>;
export type BotStatus = 1 | 2;
export declare const BotStatus: S.Literals<readonly [1, 2]>;
export interface GetBotResponse {
    botId?: string;
    displayName?: string;
    username?: string;
    uname?: string;
    pubkey?: string;
    status?: BotStatus;
    groupId?: string;
    hasChallenge?: boolean;
    suspended?: boolean;
    lastLogin?: string;
}
export declare const GetBotResponse: S.Schema<GetBotResponse>;
export interface GetBotsCountRequest {
    networkId: string;
}
export declare const GetBotsCountRequest: S.Schema<GetBotsCountRequest>;
export interface GetBotsCountResponse {
    pending: number;
    active: number;
    total: number;
}
export declare const GetBotsCountResponse: S.Schema<GetBotsCountResponse>;
export interface GetDataRetentionBotRequest {
    networkId: string;
}
export declare const GetDataRetentionBotRequest: S.Schema<GetDataRetentionBotRequest>;
export interface GetDataRetentionBotResponse {
    botName?: string;
    botExists?: boolean;
    isBotActive?: boolean;
    isDataRetentionBotRegistered?: boolean;
    isDataRetentionServiceEnabled?: boolean;
    isPubkeyMsgAcked?: boolean;
}
export declare const GetDataRetentionBotResponse: S.Schema<GetDataRetentionBotResponse>;
export interface GetGuestUserHistoryCountRequest {
    networkId: string;
}
export declare const GetGuestUserHistoryCountRequest: S.Schema<GetGuestUserHistoryCountRequest>;
export interface GuestUserHistoryCount {
    month: string;
    count: string;
}
export declare const GuestUserHistoryCount: S.Schema<GuestUserHistoryCount>;
export type GuestUserHistoryCountList = GuestUserHistoryCount[];
export declare const GuestUserHistoryCountList: S.$Array<S.Schema<GuestUserHistoryCount>>;
export interface GetGuestUserHistoryCountResponse {
    history: GuestUserHistoryCount[];
}
export declare const GetGuestUserHistoryCountResponse: S.Schema<GetGuestUserHistoryCountResponse>;
export interface GetNetworkRequest {
    networkId: string;
}
export declare const GetNetworkRequest: S.Schema<GetNetworkRequest>;
export interface GetNetworkResponse {
    networkId: string;
    networkName: string;
    accessLevel: AccessLevel;
    awsAccountId: string;
    networkArn: string;
    standing?: number;
    freeTrialExpiration?: string;
    migrationState?: number;
    encryptionKeyArn?: string;
}
export declare const GetNetworkResponse: S.Schema<GetNetworkResponse>;
export interface GetNetworkSettingsRequest {
    networkId: string;
}
export declare const GetNetworkSettingsRequest: S.Schema<GetNetworkSettingsRequest>;
export interface Setting {
    optionName: string;
    value: string;
    type: string;
}
export declare const Setting: S.Schema<Setting>;
export type SettingsList = Setting[];
export declare const SettingsList: S.$Array<S.Schema<Setting>>;
export interface GetNetworkSettingsResponse {
    settings: Setting[];
}
export declare const GetNetworkSettingsResponse: S.Schema<GetNetworkSettingsResponse>;
export interface GetOidcInfoRequest {
    networkId: string;
    clientId?: string;
    code?: string;
    grantType?: string;
    redirectUri?: string;
    url?: string;
    clientSecret?: string | redacted.Redacted<string>;
    codeVerifier?: string;
    certificate?: string;
}
export declare const GetOidcInfoRequest: S.Schema<GetOidcInfoRequest>;
export interface OidcConfigInfo {
    applicationName?: string;
    clientId?: string;
    companyId: string;
    scopes: string;
    issuer: string;
    clientSecret?: string | redacted.Redacted<string>;
    secret?: string | redacted.Redacted<string>;
    redirectUrl?: string;
    userId?: string;
    customUsername?: string;
    caCertificate?: string;
    applicationId?: number;
    ssoTokenBufferMinutes?: number;
    extraAuthParams?: string;
}
export declare const OidcConfigInfo: S.Schema<OidcConfigInfo>;
export interface OidcTokenInfo {
    codeVerifier?: string;
    codeChallenge?: string;
    accessToken?: string;
    idToken?: string;
    refreshToken?: string;
    tokenType?: string;
    expiresIn?: number;
}
export declare const OidcTokenInfo: S.Schema<OidcTokenInfo>;
export interface GetOidcInfoResponse {
    openidConnectInfo?: OidcConfigInfo;
    tokenInfo?: OidcTokenInfo;
}
export declare const GetOidcInfoResponse: S.Schema<GetOidcInfoResponse>;
export interface GetOpentdfConfigRequest {
    networkId: string;
}
export declare const GetOpentdfConfigRequest: S.Schema<GetOpentdfConfigRequest>;
export interface GetOpentdfConfigResponse {
    clientId: string;
    domain: string;
    clientSecret: string | redacted.Redacted<string>;
    provider: string;
}
export declare const GetOpentdfConfigResponse: S.Schema<GetOpentdfConfigResponse>;
export interface GetSecurityGroupRequest {
    networkId: string;
    groupId: string;
}
export declare const GetSecurityGroupRequest: S.Schema<GetSecurityGroupRequest>;
export interface GetSecurityGroupResponse {
    securityGroup: SecurityGroup;
}
export declare const GetSecurityGroupResponse: S.Schema<GetSecurityGroupResponse>;
export interface GetUserRequest {
    networkId: string;
    userId: string;
    startTime?: Date;
    endTime?: Date;
}
export declare const GetUserRequest: S.Schema<GetUserRequest>;
export interface GetUserResponse {
    userId: string;
    firstName?: string | redacted.Redacted<string>;
    lastName?: string | redacted.Redacted<string>;
    username?: string;
    isAdmin?: boolean;
    suspended?: boolean;
    status?: number;
    lastActivity?: number;
    lastLogin?: number;
    securityGroupIds?: string[];
}
export declare const GetUserResponse: S.Schema<GetUserResponse>;
export interface GetUsersCountRequest {
    networkId: string;
}
export declare const GetUsersCountRequest: S.Schema<GetUsersCountRequest>;
export interface GetUsersCountResponse {
    pending: number;
    active: number;
    rejected: number;
    remaining: number;
    total: number;
}
export declare const GetUsersCountResponse: S.Schema<GetUsersCountResponse>;
export type SortDirection = "ASC" | "DESC" | (string & {});
export declare const SortDirection: S.String;
export interface ListBlockedGuestUsersRequest {
    networkId: string;
    maxResults?: number;
    sortDirection?: SortDirection;
    sortFields?: string;
    username?: string;
    admin?: string;
    nextToken?: string;
}
export declare const ListBlockedGuestUsersRequest: S.Schema<ListBlockedGuestUsersRequest>;
export interface BlockedGuestUser {
    username: string;
    admin: string;
    modified: string;
    usernameHash: string;
}
export declare const BlockedGuestUser: S.Schema<BlockedGuestUser>;
export type BlockedGuestUserList = BlockedGuestUser[];
export declare const BlockedGuestUserList: S.$Array<S.Schema<BlockedGuestUser>>;
export interface ListBlockedGuestUsersResponse {
    nextToken?: string;
    blocklist: BlockedGuestUser[];
}
export declare const ListBlockedGuestUsersResponse: S.Schema<ListBlockedGuestUsersResponse>;
export interface ListBotsRequest {
    networkId: string;
    nextToken?: string;
    maxResults?: number;
    sortFields?: string;
    sortDirection?: SortDirection;
    displayName?: string;
    username?: string;
    status?: BotStatus;
    groupId?: string;
}
export declare const ListBotsRequest: S.Schema<ListBotsRequest>;
export interface Bot {
    botId?: string;
    displayName?: string;
    username?: string;
    uname?: string;
    pubkey?: string;
    status?: BotStatus;
    groupId?: string;
    hasChallenge?: boolean;
    suspended?: boolean;
    lastLogin?: string;
}
export declare const Bot: S.Schema<Bot>;
export type Bots = Bot[];
export declare const Bots: S.$Array<S.Schema<Bot>>;
export interface ListBotsResponse {
    bots: Bot[];
    nextToken?: string;
}
export declare const ListBotsResponse: S.Schema<ListBotsResponse>;
export interface ListDevicesForUserRequest {
    networkId: string;
    userId: string;
    nextToken?: string;
    maxResults?: number;
    sortFields?: string;
    sortDirection?: SortDirection;
}
export declare const ListDevicesForUserRequest: S.Schema<ListDevicesForUserRequest>;
export interface BasicDeviceObject {
    appId?: string;
    created?: string;
    lastLogin?: string;
    statusText?: string;
    suspend?: boolean;
    type?: string;
}
export declare const BasicDeviceObject: S.Schema<BasicDeviceObject>;
export type Devices = BasicDeviceObject[];
export declare const Devices: S.$Array<S.Schema<BasicDeviceObject>>;
export interface ListDevicesForUserResponse {
    nextToken?: string;
    devices: BasicDeviceObject[];
}
export declare const ListDevicesForUserResponse: S.Schema<ListDevicesForUserResponse>;
export interface ListGuestUsersRequest {
    networkId: string;
    maxResults?: number;
    sortDirection?: SortDirection;
    sortFields?: string;
    username?: string;
    billingPeriod?: string;
    nextToken?: string;
}
export declare const ListGuestUsersRequest: S.Schema<ListGuestUsersRequest>;
export interface GuestUser {
    billingPeriod: string;
    username: string;
    usernameHash: string;
}
export declare const GuestUser: S.Schema<GuestUser>;
export type GuestUserList = GuestUser[];
export declare const GuestUserList: S.$Array<S.Schema<GuestUser>>;
export interface ListGuestUsersResponse {
    nextToken?: string;
    guestlist: GuestUser[];
}
export declare const ListGuestUsersResponse: S.Schema<ListGuestUsersResponse>;
export interface ListNetworksRequest {
    maxResults?: number;
    sortFields?: string;
    sortDirection?: SortDirection;
    nextToken?: string;
}
export declare const ListNetworksRequest: S.Schema<ListNetworksRequest>;
export interface Network {
    networkId: string;
    networkName: string;
    accessLevel: AccessLevel;
    awsAccountId: string;
    networkArn: string;
    standing?: number;
    freeTrialExpiration?: string;
    migrationState?: number;
    encryptionKeyArn?: string;
}
export declare const Network: S.Schema<Network>;
export type NetworkList = Network[];
export declare const NetworkList: S.$Array<S.Schema<Network>>;
export interface ListNetworksResponse {
    networks: Network[];
    nextToken?: string;
}
export declare const ListNetworksResponse: S.Schema<ListNetworksResponse>;
export interface ListSecurityGroupsRequest {
    networkId: string;
    nextToken?: string;
    maxResults?: number;
    sortFields?: string;
    sortDirection?: SortDirection;
}
export declare const ListSecurityGroupsRequest: S.Schema<ListSecurityGroupsRequest>;
export type SecurityGroupList = SecurityGroup[];
export declare const SecurityGroupList: S.$Array<S.Schema<SecurityGroup>>;
export interface ListSecurityGroupsResponse {
    securityGroups?: SecurityGroup[];
    nextToken?: string;
}
export declare const ListSecurityGroupsResponse: S.Schema<ListSecurityGroupsResponse>;
export interface ListSecurityGroupUsersRequest {
    networkId: string;
    groupId: string;
    nextToken?: string;
    maxResults?: number;
    sortFields?: string;
    sortDirection?: SortDirection;
}
export declare const ListSecurityGroupUsersRequest: S.Schema<ListSecurityGroupUsersRequest>;
export interface ListSecurityGroupUsersResponse {
    users: User[];
    nextToken?: string;
}
export declare const ListSecurityGroupUsersResponse: S.Schema<ListSecurityGroupUsersResponse>;
export type UserStatus = 1 | 2;
export declare const UserStatus: S.Literals<readonly [1, 2]>;
export interface ListUsersRequest {
    networkId: string;
    nextToken?: string;
    maxResults?: number;
    sortFields?: string;
    sortDirection?: SortDirection;
    firstName?: string | redacted.Redacted<string>;
    lastName?: string | redacted.Redacted<string>;
    username?: string;
    status?: UserStatus;
    groupId?: string;
}
export declare const ListUsersRequest: S.Schema<ListUsersRequest>;
export interface ListUsersResponse {
    nextToken?: string;
    users?: User[];
}
export declare const ListUsersResponse: S.Schema<ListUsersResponse>;
export interface RegisterOidcConfigRequest {
    networkId: string;
    companyId: string;
    customUsername?: string;
    extraAuthParams?: string;
    issuer: string;
    scopes: string;
    secret?: string | redacted.Redacted<string>;
    ssoTokenBufferMinutes?: number;
    userId?: string;
}
export declare const RegisterOidcConfigRequest: S.Schema<RegisterOidcConfigRequest>;
export interface RegisterOidcConfigResponse {
    applicationName?: string;
    clientId?: string;
    companyId: string;
    scopes: string;
    issuer: string;
    clientSecret?: string | redacted.Redacted<string>;
    secret?: string | redacted.Redacted<string>;
    redirectUrl?: string;
    userId?: string;
    customUsername?: string;
    caCertificate?: string;
    applicationId?: number;
    ssoTokenBufferMinutes?: number;
    extraAuthParams?: string;
}
export declare const RegisterOidcConfigResponse: S.Schema<RegisterOidcConfigResponse>;
export interface RegisterOidcConfigTestRequest {
    networkId: string;
    extraAuthParams?: string;
    issuer: string;
    scopes: string;
    certificate?: string;
}
export declare const RegisterOidcConfigTestRequest: S.Schema<RegisterOidcConfigTestRequest>;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export interface RegisterOidcConfigTestResponse {
    tokenEndpoint?: string;
    userinfoEndpoint?: string;
    responseTypesSupported?: string[];
    scopesSupported?: string[];
    issuer?: string;
    authorizationEndpoint?: string;
    endSessionEndpoint?: string;
    logoutEndpoint?: string;
    grantTypesSupported?: string[];
    revocationEndpoint?: string;
    tokenEndpointAuthMethodsSupported?: string[];
    microsoftMultiRefreshToken?: boolean;
}
export declare const RegisterOidcConfigTestResponse: S.Schema<RegisterOidcConfigTestResponse>;
export interface RegisterOpentdfConfigRequest {
    networkId: string;
    clientId: string;
    clientSecret: string | redacted.Redacted<string>;
    domain: string;
    provider: string;
    dryRun?: boolean;
}
export declare const RegisterOpentdfConfigRequest: S.Schema<RegisterOpentdfConfigRequest>;
export interface RegisterOpentdfConfigResponse {
    clientId: string;
    domain: string;
    clientSecret: string | redacted.Redacted<string>;
    provider: string;
}
export declare const RegisterOpentdfConfigResponse: S.Schema<RegisterOpentdfConfigResponse>;
export interface UpdateBotRequest {
    networkId: string;
    botId: string;
    displayName?: string;
    groupId?: string;
    challenge?: string | redacted.Redacted<string>;
    suspend?: boolean;
}
export declare const UpdateBotRequest: S.Schema<UpdateBotRequest>;
export interface UpdateBotResponse {
    message?: string;
}
export declare const UpdateBotResponse: S.Schema<UpdateBotResponse>;
export type DataRetentionActionType = "ENABLE" | "DISABLE" | "PUBKEY_MSG_ACK" | (string & {});
export declare const DataRetentionActionType: S.String;
export interface UpdateDataRetentionRequest {
    networkId: string;
    actionType: DataRetentionActionType;
}
export declare const UpdateDataRetentionRequest: S.Schema<UpdateDataRetentionRequest>;
export interface UpdateDataRetentionResponse {
    message?: string;
}
export declare const UpdateDataRetentionResponse: S.Schema<UpdateDataRetentionResponse>;
export interface UpdateGuestUserRequest {
    networkId: string;
    usernameHash: string;
    block: boolean;
}
export declare const UpdateGuestUserRequest: S.Schema<UpdateGuestUserRequest>;
export interface UpdateGuestUserResponse {
    message?: string;
}
export declare const UpdateGuestUserResponse: S.Schema<UpdateGuestUserResponse>;
export interface UpdateNetworkRequest {
    networkId: string;
    networkName: string;
    clientToken?: string;
    encryptionKeyArn?: string;
}
export declare const UpdateNetworkRequest: S.Schema<UpdateNetworkRequest>;
export interface UpdateNetworkResponse {
    message?: string;
}
export declare const UpdateNetworkResponse: S.Schema<UpdateNetworkResponse>;
export type Status = "DISABLED" | "ENABLED" | "FORCE_ENABLED" | (string & {});
export declare const Status: S.String;
export interface ReadReceiptConfig {
    status?: Status;
}
export declare const ReadReceiptConfig: S.Schema<ReadReceiptConfig>;
export interface NetworkSettings {
    enableClientMetrics?: boolean;
    readReceiptConfig?: ReadReceiptConfig;
    dataRetention?: boolean;
    enableTrustedDataFormat?: boolean;
}
export declare const NetworkSettings: S.Schema<NetworkSettings>;
export interface UpdateNetworkSettingsRequest {
    networkId: string;
    settings: NetworkSettings;
}
export declare const UpdateNetworkSettingsRequest: S.Schema<UpdateNetworkSettingsRequest>;
export interface UpdateNetworkSettingsResponse {
    settings: Setting[];
}
export declare const UpdateNetworkSettingsResponse: S.Schema<UpdateNetworkSettingsResponse>;
export interface UpdateSecurityGroupRequest {
    networkId: string;
    groupId: string;
    name?: string;
    securityGroupSettings?: SecurityGroupSettings;
}
export declare const UpdateSecurityGroupRequest: S.Schema<UpdateSecurityGroupRequest>;
export interface UpdateSecurityGroupResponse {
    securityGroup: SecurityGroup;
}
export declare const UpdateSecurityGroupResponse: S.Schema<UpdateSecurityGroupResponse>;
export interface UpdateUserDetails {
    firstName?: string | redacted.Redacted<string>;
    lastName?: string | redacted.Redacted<string>;
    username?: string;
    securityGroupIds?: string[];
    inviteCode?: string;
    inviteCodeTtl?: number;
    codeValidation?: boolean;
}
export declare const UpdateUserDetails: S.Schema<UpdateUserDetails>;
export interface UpdateUserRequest {
    networkId: string;
    userId: string;
    userDetails?: UpdateUserDetails;
}
export declare const UpdateUserRequest: S.Schema<UpdateUserRequest>;
export interface UpdateUserResponse {
    userId: string;
    networkId: string;
    securityGroupIds?: string[];
    firstName?: string | redacted.Redacted<string>;
    lastName?: string | redacted.Redacted<string>;
    middleName?: string;
    suspended: boolean;
    modified?: number;
    status?: number;
    inviteCode?: string;
    inviteExpiration?: number;
    codeValidation?: boolean;
}
export declare const UpdateUserResponse: S.Schema<UpdateUserResponse>;
declare const BadRequestError_base: S.Class<BadRequestError, S.TaggedStruct<"BadRequestError", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestError extends BadRequestError_base {
}
declare const ForbiddenError_base: S.Class<ForbiddenError, S.TaggedStruct<"ForbiddenError", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class ForbiddenError extends ForbiddenError_base {
}
declare const InternalServerError_base: S.Class<InternalServerError, S.TaggedStruct<"InternalServerError", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerError extends InternalServerError_base {
}
declare const RateLimitError_base: S.Class<RateLimitError, S.TaggedStruct<"RateLimitError", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class RateLimitError extends RateLimitError_base {
}
declare const ResourceNotFoundError_base: S.Class<ResourceNotFoundError, S.TaggedStruct<"ResourceNotFoundError", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundError extends ResourceNotFoundError_base {
}
declare const UnauthorizedError_base: S.Class<UnauthorizedError, S.TaggedStruct<"UnauthorizedError", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class UnauthorizedError extends UnauthorizedError_base {
}
declare const ValidationError_base: S.Class<ValidationError, S.TaggedStruct<"ValidationError", {
    readonly reasons: S.optional<S.$Array<S.Schema<ErrorDetail>>>;
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationError extends ValidationError_base {
}
export type BatchCreateUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Creates multiple users in a specified Wickr network. This operation allows you to provision multiple user accounts simultaneously, optionally specifying security groups, and validation requirements for each user.
 *
 * `codeValidation`, `inviteCode`, and `inviteCodeTtl` are restricted to networks under preview only.
 */
export declare const batchCreateUser: API.OperationMethod<BatchCreateUserRequest, BatchCreateUserResponse, BatchCreateUserError, Credentials | Region | HttpClient.HttpClient>;
export type BatchDeleteUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Deletes multiple users from a specified Wickr network. This operation permanently removes user accounts and their associated data from the network.
 */
export declare const batchDeleteUser: API.OperationMethod<BatchDeleteUserRequest, BatchDeleteUserResponse, BatchDeleteUserError, Credentials | Region | HttpClient.HttpClient>;
export type BatchLookupUserUnameError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Looks up multiple user usernames from their unique username hashes (unames). This operation allows you to retrieve the email addresses associated with a list of username hashes.
 */
export declare const batchLookupUserUname: API.OperationMethod<BatchLookupUserUnameRequest, BatchLookupUserUnameResponse, BatchLookupUserUnameError, Credentials | Region | HttpClient.HttpClient>;
export type BatchReinviteUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Resends invitation codes to multiple users who have pending invitations in a Wickr network. This operation is useful when users haven't accepted their initial invitations or when invitations have expired.
 */
export declare const batchReinviteUser: API.OperationMethod<BatchReinviteUserRequest, BatchReinviteUserResponse, BatchReinviteUserError, Credentials | Region | HttpClient.HttpClient>;
export type BatchResetDevicesForUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Resets multiple devices for a specific user in a Wickr network. This operation forces the selected devices to log out and requires users to re-authenticate, which is useful for security purposes or when devices need to be revoked.
 */
export declare const batchResetDevicesForUser: API.OperationMethod<BatchResetDevicesForUserRequest, BatchResetDevicesForUserResponse, BatchResetDevicesForUserError, Credentials | Region | HttpClient.HttpClient>;
export type BatchToggleUserSuspendStatusError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Suspends or unsuspends multiple users in a Wickr network. Suspended users cannot access the network until they are unsuspended. This operation is useful for temporarily restricting access without deleting user accounts.
 */
export declare const batchToggleUserSuspendStatus: API.OperationMethod<BatchToggleUserSuspendStatusRequest, BatchToggleUserSuspendStatusResponse, BatchToggleUserSuspendStatusError, Credentials | Region | HttpClient.HttpClient>;
export type CreateBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Creates a new bot in a specified Wickr network. Bots are automated accounts that can send and receive messages, enabling integration with external systems and automation of tasks.
 */
export declare const createBot: API.OperationMethod<CreateBotRequest, CreateBotResponse, CreateBotError, Credentials | Region | HttpClient.HttpClient>;
export type CreateDataRetentionBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Creates a data retention bot in a Wickr network. Data retention bots are specialized bots that handle message archiving and compliance by capturing and storing messages for regulatory or organizational requirements.
 */
export declare const createDataRetentionBot: API.OperationMethod<CreateDataRetentionBotRequest, CreateDataRetentionBotResponse, CreateDataRetentionBotError, Credentials | Region | HttpClient.HttpClient>;
export type CreateDataRetentionBotChallengeError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Creates a new challenge password for the data retention bot. This password is used for authentication when the bot connects to the network.
 */
export declare const createDataRetentionBotChallenge: API.OperationMethod<CreateDataRetentionBotChallengeRequest, CreateDataRetentionBotChallengeResponse, CreateDataRetentionBotChallengeError, Credentials | Region | HttpClient.HttpClient>;
export type CreateNetworkError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Creates a new Wickr network with specified access level and configuration. This operation provisions a new communication network for your organization.
 */
export declare const createNetwork: API.OperationMethod<CreateNetworkRequest, CreateNetworkResponse, CreateNetworkError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSecurityGroupError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Creates a new security group in a Wickr network. Security groups allow you to organize users and control their permissions, features, and security settings.
 */
export declare const createSecurityGroup: API.OperationMethod<CreateSecurityGroupRequest, CreateSecurityGroupResponse, CreateSecurityGroupError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Deletes a bot from a specified Wickr network. This operation permanently removes the bot account and its associated data from the network.
 */
export declare const deleteBot: API.OperationMethod<DeleteBotRequest, DeleteBotResponse, DeleteBotError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteDataRetentionBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Deletes the data retention bot from a Wickr network. This operation permanently removes the bot and all its associated data from the database.
 */
export declare const deleteDataRetentionBot: API.OperationMethod<DeleteDataRetentionBotRequest, DeleteDataRetentionBotResponse, DeleteDataRetentionBotError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteNetworkError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Deletes a Wickr network and all its associated resources, including users, bots, security groups, and settings. This operation is permanent and cannot be undone.
 */
export declare const deleteNetwork: API.OperationMethod<DeleteNetworkRequest, DeleteNetworkResponse, DeleteNetworkError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSecurityGroupError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Deletes a security group from a Wickr network. This operation cannot be performed on the default security group.
 */
export declare const deleteSecurityGroup: API.OperationMethod<DeleteSecurityGroupRequest, DeleteSecurityGroupResponse, DeleteSecurityGroupError, Credentials | Region | HttpClient.HttpClient>;
export type GetBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves detailed information about a specific bot in a Wickr network, including its status, group membership, and authentication details.
 */
export declare const getBot: API.OperationMethod<GetBotRequest, GetBotResponse, GetBotError, Credentials | Region | HttpClient.HttpClient>;
export type GetBotsCountError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves the count of bots in a Wickr network, categorized by their status (pending, active, and total).
 */
export declare const getBotsCount: API.OperationMethod<GetBotsCountRequest, GetBotsCountResponse, GetBotsCountError, Credentials | Region | HttpClient.HttpClient>;
export type GetDataRetentionBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves information about the data retention bot in a Wickr network, including its status and whether the data retention service is enabled.
 */
export declare const getDataRetentionBot: API.OperationMethod<GetDataRetentionBotRequest, GetDataRetentionBotResponse, GetDataRetentionBotError, Credentials | Region | HttpClient.HttpClient>;
export type GetGuestUserHistoryCountError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves historical guest user count data for a Wickr network, showing the number of guest users per billing period over the past 90 days.
 */
export declare const getGuestUserHistoryCount: API.OperationMethod<GetGuestUserHistoryCountRequest, GetGuestUserHistoryCountResponse, GetGuestUserHistoryCountError, Credentials | Region | HttpClient.HttpClient>;
export type GetNetworkError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves detailed information about a specific Wickr network, including its configuration, access level, and status.
 */
export declare const getNetwork: API.OperationMethod<GetNetworkRequest, GetNetworkResponse, GetNetworkError, Credentials | Region | HttpClient.HttpClient>;
export type GetNetworkSettingsError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves all network-level settings for a Wickr network, including client metrics, data retention, and other configuration options.
 */
export declare const getNetworkSettings: API.OperationMethod<GetNetworkSettingsRequest, GetNetworkSettingsResponse, GetNetworkSettingsError, Credentials | Region | HttpClient.HttpClient>;
export type GetOidcInfoError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves the OpenID Connect (OIDC) configuration for a Wickr network, including SSO settings and optional token information if access token parameters are provided.
 */
export declare const getOidcInfo: API.OperationMethod<GetOidcInfoRequest, GetOidcInfoResponse, GetOidcInfoError, Credentials | Region | HttpClient.HttpClient>;
export type GetOpentdfConfigError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves the OpenTDF integration configuration for a Wickr network.
 */
export declare const getOpentdfConfig: API.OperationMethod<GetOpentdfConfigRequest, GetOpentdfConfigResponse, GetOpentdfConfigError, Credentials | Region | HttpClient.HttpClient>;
export type GetSecurityGroupError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves detailed information about a specific security group in a Wickr network, including its settings, member counts, and configuration.
 */
export declare const getSecurityGroup: API.OperationMethod<GetSecurityGroupRequest, GetSecurityGroupResponse, GetSecurityGroupError, Credentials | Region | HttpClient.HttpClient>;
export type GetUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves detailed information about a specific user in a Wickr network, including their profile, status, and activity history.
 */
export declare const getUser: API.OperationMethod<GetUserRequest, GetUserResponse, GetUserError, Credentials | Region | HttpClient.HttpClient>;
export type GetUsersCountError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves the count of users in a Wickr network, categorized by their status (pending, active, rejected) and showing how many users can still be added.
 */
export declare const getUsersCount: API.OperationMethod<GetUsersCountRequest, GetUsersCountResponse, GetUsersCountError, Credentials | Region | HttpClient.HttpClient>;
export type ListBlockedGuestUsersError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of guest users who have been blocked from a Wickr network. You can filter and sort the results.
 */
export declare const listBlockedGuestUsers: API.OperationMethod<ListBlockedGuestUsersRequest, ListBlockedGuestUsersResponse, ListBlockedGuestUsersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListBlockedGuestUsersRequest) => stream.Stream<ListBlockedGuestUsersResponse, ListBlockedGuestUsersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListBlockedGuestUsersRequest) => stream.Stream<BlockedGuestUser, ListBlockedGuestUsersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListBotsError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of bots in a specified Wickr network. You can filter and sort the results based on various criteria.
 */
export declare const listBots: API.OperationMethod<ListBotsRequest, ListBotsResponse, ListBotsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListBotsRequest) => stream.Stream<ListBotsResponse, ListBotsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListBotsRequest) => stream.Stream<Bot, ListBotsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListDevicesForUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of devices associated with a specific user in a Wickr network. This operation returns information about all devices where the user has logged into Wickr.
 */
export declare const listDevicesForUser: API.OperationMethod<ListDevicesForUserRequest, ListDevicesForUserResponse, ListDevicesForUserError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDevicesForUserRequest) => stream.Stream<ListDevicesForUserResponse, ListDevicesForUserError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDevicesForUserRequest) => stream.Stream<BasicDeviceObject, ListDevicesForUserError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListGuestUsersError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of guest users who have communicated with your Wickr network. Guest users are external users from federated networks who can communicate with network members.
 */
export declare const listGuestUsers: API.OperationMethod<ListGuestUsersRequest, ListGuestUsersResponse, ListGuestUsersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListGuestUsersRequest) => stream.Stream<ListGuestUsersResponse, ListGuestUsersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListGuestUsersRequest) => stream.Stream<GuestUser, ListGuestUsersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListNetworksError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of all Wickr networks associated with your Amazon Web Services account. You can sort the results by network ID or name.
 */
export declare const listNetworks: API.OperationMethod<ListNetworksRequest, ListNetworksResponse, ListNetworksError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListNetworksRequest) => stream.Stream<ListNetworksResponse, ListNetworksError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListNetworksRequest) => stream.Stream<Network, ListNetworksError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSecurityGroupsError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of security groups in a specified Wickr network. You can sort the results by various criteria.
 */
export declare const listSecurityGroups: API.OperationMethod<ListSecurityGroupsRequest, ListSecurityGroupsResponse, ListSecurityGroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSecurityGroupsRequest) => stream.Stream<ListSecurityGroupsResponse, ListSecurityGroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSecurityGroupsRequest) => stream.Stream<SecurityGroup, ListSecurityGroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSecurityGroupUsersError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of users who belong to a specific security group in a Wickr network.
 */
export declare const listSecurityGroupUsers: API.OperationMethod<ListSecurityGroupUsersRequest, ListSecurityGroupUsersResponse, ListSecurityGroupUsersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSecurityGroupUsersRequest) => stream.Stream<ListSecurityGroupUsersResponse, ListSecurityGroupUsersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSecurityGroupUsersRequest) => stream.Stream<User, ListSecurityGroupUsersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListUsersError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Retrieves a paginated list of users in a specified Wickr network. You can filter and sort the results based on various criteria such as name, status, or security group membership.
 */
export declare const listUsers: API.OperationMethod<ListUsersRequest, ListUsersResponse, ListUsersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListUsersRequest) => stream.Stream<ListUsersResponse, ListUsersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListUsersRequest) => stream.Stream<User, ListUsersError, Credentials | Region | HttpClient.HttpClient>;
};
export type RegisterOidcConfigError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Registers and saves an OpenID Connect (OIDC) configuration for a Wickr network, enabling Single Sign-On (SSO) authentication through an identity provider.
 */
export declare const registerOidcConfig: API.OperationMethod<RegisterOidcConfigRequest, RegisterOidcConfigResponse, RegisterOidcConfigError, Credentials | Region | HttpClient.HttpClient>;
export type RegisterOidcConfigTestError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Tests an OpenID Connect (OIDC) configuration for a Wickr network by validating the connection to the identity provider and retrieving its supported capabilities.
 */
export declare const registerOidcConfigTest: API.OperationMethod<RegisterOidcConfigTestRequest, RegisterOidcConfigTestResponse, RegisterOidcConfigTestError, Credentials | Region | HttpClient.HttpClient>;
export type RegisterOpentdfConfigError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Registers and saves OpenTDF configuration for a Wickr network, enabling attribute-based access control for Wickr through an OpenTDF provider.
 */
export declare const registerOpentdfConfig: API.OperationMethod<RegisterOpentdfConfigRequest, RegisterOpentdfConfigResponse, RegisterOpentdfConfigError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateBotError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates the properties of an existing bot in a Wickr network. This operation allows you to modify the bot's display name, security group, password, or suspension status.
 */
export declare const updateBot: API.OperationMethod<UpdateBotRequest, UpdateBotResponse, UpdateBotError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateDataRetentionError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates the data retention bot settings, allowing you to enable or disable the data retention service, or acknowledge the public key message.
 */
export declare const updateDataRetention: API.OperationMethod<UpdateDataRetentionRequest, UpdateDataRetentionResponse, UpdateDataRetentionError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateGuestUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates the block status of a guest user in a Wickr network. This operation allows you to block or unblock a guest user from accessing the network.
 */
export declare const updateGuestUser: API.OperationMethod<UpdateGuestUserRequest, UpdateGuestUserResponse, UpdateGuestUserError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateNetworkError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates the properties of an existing Wickr network, such as its name or encryption key configuration.
 */
export declare const updateNetwork: API.OperationMethod<UpdateNetworkRequest, UpdateNetworkResponse, UpdateNetworkError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateNetworkSettingsError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates network-level settings for a Wickr network. You can modify settings such as client metrics, data retention, and other network-wide options.
 */
export declare const updateNetworkSettings: API.OperationMethod<UpdateNetworkSettingsRequest, UpdateNetworkSettingsResponse, UpdateNetworkSettingsError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSecurityGroupError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates the properties of an existing security group in a Wickr network, such as its name or settings.
 */
export declare const updateSecurityGroup: API.OperationMethod<UpdateSecurityGroupRequest, UpdateSecurityGroupResponse, UpdateSecurityGroupError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateUserError = BadRequestError | ForbiddenError | InternalServerError | RateLimitError | ResourceNotFoundError | UnauthorizedError | ValidationError | CommonErrors;
/**
 * Updates the properties of an existing user in a Wickr network. This operation allows you to modify the user's name, password, security group membership, and invite code settings.
 *
 * `codeValidation`, `inviteCode`, and `inviteCodeTtl` are restricted to networks under preview only.
 */
export declare const updateUser: API.OperationMethod<UpdateUserRequest, UpdateUserResponse, UpdateUserError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=wickr.d.ts.map