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.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const svc = T.AwsApiService({
    sdkId: "Wickr",
    serviceShapeName: "WickrAdminApi",
});
const auth = T.AwsAuthSigv4({ name: "wickr" });
const ver = T.ServiceVersion("2024-02-01");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://admin.wickr-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://admin.wickr-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://admin.wickr.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://admin.wickr.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const SecurityGroupIdList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const BatchCreateUserRequestItem = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    firstName: S.optional(SensitiveString),
    lastName: S.optional(SensitiveString),
    securityGroupIds: SecurityGroupIdList,
    username: S.String,
    inviteCode: S.optional(S.String),
    inviteCodeTtl: S.optional(S.Number),
    codeValidation: S.optional(S.Boolean),
})).annotate({
    identifier: "BatchCreateUserRequestItem",
});
export const BatchCreateUserRequestItems = /*@__PURE__*/ /*#__PURE__*/ S.Array(BatchCreateUserRequestItem);
export const BatchCreateUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    users: BatchCreateUserRequestItems,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({ method: "POST", uri: "/networks/{networkId}/users" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchCreateUserRequest",
});
export const User = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    userId: S.optional(S.String),
    firstName: S.optional(SensitiveString),
    lastName: S.optional(SensitiveString),
    username: S.optional(S.String),
    securityGroups: S.optional(SecurityGroupIdList),
    isAdmin: S.optional(S.Boolean),
    suspended: S.optional(S.Boolean),
    status: S.optional(S.Number),
    otpEnabled: S.optional(S.Boolean),
    scimId: S.optional(S.String),
    type: S.optional(S.String),
    cell: S.optional(S.String),
    countryCode: S.optional(S.String),
    challengeFailures: S.optional(S.Number),
    isInviteExpired: S.optional(S.Boolean),
    isUser: S.optional(S.Boolean),
    inviteCode: S.optional(S.String),
    codeValidation: S.optional(S.Boolean),
    uname: S.optional(S.String),
})).annotate({ identifier: "User" });
export const Users = /*@__PURE__*/ /*#__PURE__*/ S.Array(User);
export const BatchUserErrorResponseItem = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    field: S.optional(S.String),
    reason: S.optional(S.String),
    userId: S.String,
})).annotate({
    identifier: "BatchUserErrorResponseItem",
});
export const BatchUserErrorResponseItems = /*@__PURE__*/ /*#__PURE__*/ S.Array(BatchUserErrorResponseItem);
export const BatchCreateUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    successful: S.optional(Users),
    failed: S.optional(BatchUserErrorResponseItems),
})).annotate({
    identifier: "BatchCreateUserResponse",
});
export const ErrorDetail = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ field: S.optional(S.String), reason: S.optional(S.String) })).annotate({ identifier: "ErrorDetail" });
export const ErrorDetailList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ErrorDetail);
export const UserIds = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const BatchDeleteUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    userIds: UserIds,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/networks/{networkId}/users/batch-delete",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchDeleteUserRequest",
});
export const BatchUserSuccessResponseItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ userId: S.String })).annotate({
    identifier: "BatchUserSuccessResponseItem",
});
export const BatchUserSuccessResponseItems = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BatchUserSuccessResponseItem);
export const BatchDeleteUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    successful: S.optional(BatchUserSuccessResponseItems),
    failed: S.optional(BatchUserErrorResponseItems),
})).annotate({
    identifier: "BatchDeleteUserResponse",
});
export const Unames = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const BatchLookupUserUnameRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    unames: Unames,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/networks/{networkId}/users/uname-lookup",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchLookupUserUnameRequest",
});
export const BatchUnameSuccessResponseItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ uname: S.String, username: S.String })).annotate({
    identifier: "BatchUnameSuccessResponseItem",
});
export const BatchUnameSuccessResponseItems = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BatchUnameSuccessResponseItem);
export const BatchUnameErrorResponseItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    field: S.optional(S.String),
    reason: S.optional(S.String),
    uname: S.String,
})).annotate({
    identifier: "BatchUnameErrorResponseItem",
});
export const BatchUnameErrorResponseItems = /*@__PURE__*/ /*#__PURE__*/ S.Array(BatchUnameErrorResponseItem);
export const BatchLookupUserUnameResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    successful: S.optional(BatchUnameSuccessResponseItems),
    failed: S.optional(BatchUnameErrorResponseItems),
})).annotate({
    identifier: "BatchLookupUserUnameResponse",
});
export const BatchReinviteUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    userIds: UserIds,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({
    method: "PATCH",
    uri: "/networks/{networkId}/users/re-invite",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchReinviteUserRequest",
});
export const BatchReinviteUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    successful: S.optional(BatchUserSuccessResponseItems),
    failed: S.optional(BatchUserErrorResponseItems),
})).annotate({
    identifier: "BatchReinviteUserResponse",
});
export const AppIds = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const BatchResetDevicesForUserRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    appIds: AppIds,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({
    method: "PATCH",
    uri: "/networks/{networkId}/users/{userId}/devices",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchResetDevicesForUserRequest",
});
export const BatchDeviceSuccessResponseItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ appId: S.String })).annotate({
    identifier: "BatchDeviceSuccessResponseItem",
});
export const BatchDeviceSuccessResponseItems = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BatchDeviceSuccessResponseItem);
export const BatchDeviceErrorResponseItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    field: S.optional(S.String),
    reason: S.optional(S.String),
    appId: S.String,
})).annotate({
    identifier: "BatchDeviceErrorResponseItem",
});
export const BatchDeviceErrorResponseItems = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BatchDeviceErrorResponseItem);
export const BatchResetDevicesForUserResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    successful: S.optional(BatchDeviceSuccessResponseItems),
    failed: S.optional(BatchDeviceErrorResponseItems),
})).annotate({
    identifier: "BatchResetDevicesForUserResponse",
});
export const BatchToggleUserSuspendStatusRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    suspend: S.Boolean.pipe(T.HttpQuery("suspend")),
    userIds: UserIds,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({
    method: "PATCH",
    uri: "/networks/{networkId}/users/toggleSuspend",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchToggleUserSuspendStatusRequest",
});
export const BatchToggleUserSuspendStatusResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    successful: S.optional(BatchUserSuccessResponseItems),
    failed: S.optional(BatchUserErrorResponseItems),
})).annotate({
    identifier: "BatchToggleUserSuspendStatusResponse",
});
export const CreateBotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    username: S.String,
    displayName: S.optional(S.String),
    groupId: S.String,
    challenge: SensitiveString,
}).pipe(T.all(T.Http({ method: "POST", uri: "/networks/{networkId}/bots" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateBotRequest",
});
export const CreateBotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    botId: S.String,
    networkId: S.optional(S.String),
    username: S.optional(S.String),
    displayName: S.optional(S.String),
    groupId: S.optional(S.String),
})).annotate({
    identifier: "CreateBotResponse",
});
export const CreateDataRetentionBotRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({
    method: "POST",
    uri: "/networks/{networkId}/data-retention-bots",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateDataRetentionBotRequest",
});
export const CreateDataRetentionBotResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "CreateDataRetentionBotResponse",
});
export const CreateDataRetentionBotChallengeRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({
    method: "POST",
    uri: "/networks/{networkId}/data-retention-bots/challenge",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateDataRetentionBotChallengeRequest",
});
export const CreateDataRetentionBotChallengeResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ challenge: SensitiveString })).annotate({
    identifier: "CreateDataRetentionBotChallengeResponse",
});
export const AccessLevel = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateNetworkRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkName: S.String,
    accessLevel: AccessLevel,
    enablePremiumFreeTrial: S.optional(S.Boolean),
    encryptionKeyArn: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/networks" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateNetworkRequest",
});
export const CreateNetworkResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.optional(S.String),
    networkName: S.optional(S.String),
    encryptionKeyArn: S.optional(S.String),
})).annotate({
    identifier: "CreateNetworkResponse",
});
export const PermittedNetworksList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const WickrAwsNetworks = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ region: S.String, networkId: S.String })).annotate({
    identifier: "WickrAwsNetworks",
});
export const WickrAwsNetworksList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(WickrAwsNetworks);
export const PermittedWickrEnterpriseNetwork = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ domain: S.String, networkId: S.String })).annotate({
    identifier: "PermittedWickrEnterpriseNetwork",
});
export const PermittedWickrEnterpriseNetworksList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PermittedWickrEnterpriseNetwork);
export const SecurityGroupSettingsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    lockoutThreshold: S.optional(S.Number),
    permittedNetworks: S.optional(PermittedNetworksList),
    enableGuestFederation: S.optional(S.Boolean),
    globalFederation: S.optional(S.Boolean),
    federationMode: S.optional(S.Number),
    enableRestrictedGlobalFederation: S.optional(S.Boolean),
    permittedWickrAwsNetworks: S.optional(WickrAwsNetworksList),
    permittedWickrEnterpriseNetworks: S.optional(PermittedWickrEnterpriseNetworksList),
})).annotate({
    identifier: "SecurityGroupSettingsRequest",
});
export const CreateSecurityGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    name: S.String,
    securityGroupSettings: SecurityGroupSettingsRequest,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({
    method: "POST",
    uri: "/networks/{networkId}/security-groups",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateSecurityGroupRequest",
});
export const SecurityGroupStringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CallingSettings = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    canStart11Call: S.optional(S.Boolean),
    canVideoCall: S.optional(S.Boolean),
    forceTcpCall: S.optional(S.Boolean),
})).annotate({
    identifier: "CallingSettings",
});
export const PasswordRequirements = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    lowercase: S.optional(S.Number),
    minLength: S.optional(S.Number),
    numbers: S.optional(S.Number),
    symbols: S.optional(S.Number),
    uppercase: S.optional(S.Number),
})).annotate({
    identifier: "PasswordRequirements",
});
export const ShredderSettings = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    canProcessManually: S.optional(S.Boolean),
    intensity: S.optional(S.Number),
})).annotate({
    identifier: "ShredderSettings",
});
export const SecurityGroupSettings = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    alwaysReauthenticate: S.optional(S.Boolean),
    atakPackageValues: S.optional(SecurityGroupStringList),
    calling: S.optional(CallingSettings),
    checkForUpdates: S.optional(S.Boolean),
    enableAtak: S.optional(S.Boolean),
    enableCrashReports: S.optional(S.Boolean),
    enableFileDownload: S.optional(S.Boolean),
    enableGuestFederation: S.optional(S.Boolean),
    enableNotificationPreview: S.optional(S.Boolean),
    enableOpenAccessOption: S.optional(S.Boolean),
    enableRestrictedGlobalFederation: S.optional(S.Boolean),
    filesEnabled: S.optional(S.Boolean),
    forceDeviceLockout: S.optional(S.Number),
    forceOpenAccess: S.optional(S.Boolean),
    forceReadReceipts: S.optional(S.Boolean),
    globalFederation: S.optional(S.Boolean),
    isAtoEnabled: S.optional(S.Boolean),
    isLinkPreviewEnabled: S.optional(S.Boolean),
    locationAllowMaps: S.optional(S.Boolean),
    locationEnabled: S.optional(S.Boolean),
    maxAutoDownloadSize: S.optional(S.Number),
    maxBor: S.optional(S.Number),
    maxTtl: S.optional(S.Number),
    messageForwardingEnabled: S.optional(S.Boolean),
    passwordRequirements: S.optional(PasswordRequirements),
    presenceEnabled: S.optional(S.Boolean),
    quickResponses: S.optional(SecurityGroupStringList),
    showMasterRecoveryKey: S.optional(S.Boolean),
    shredder: S.optional(ShredderSettings),
    ssoMaxIdleMinutes: S.optional(S.Number),
    federationMode: S.optional(S.Number),
    lockoutThreshold: S.optional(S.Number),
    permittedNetworks: S.optional(PermittedNetworksList),
    permittedWickrAwsNetworks: S.optional(WickrAwsNetworksList),
    permittedWickrEnterpriseNetworks: S.optional(PermittedWickrEnterpriseNetworksList),
})).annotate({
    identifier: "SecurityGroupSettings",
});
export const SecurityGroup = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    activeMembers: S.Number,
    botMembers: S.Number,
    activeDirectoryGuid: S.optional(S.String),
    id: S.String,
    isDefault: S.Boolean,
    name: S.String,
    modified: S.Number,
    securityGroupSettings: SecurityGroupSettings,
})).annotate({ identifier: "SecurityGroup" });
export const CreateSecurityGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ securityGroup: SecurityGroup })).annotate({
    identifier: "CreateSecurityGroupResponse",
});
export const DeleteBotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    botId: S.String.pipe(T.HttpLabel("botId")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/networks/{networkId}/bots/{botId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteBotRequest",
});
export const DeleteBotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "DeleteBotResponse",
});
export const DeleteDataRetentionBotRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/networks/{networkId}/data-retention-bots",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteDataRetentionBotRequest",
});
export const DeleteDataRetentionBotResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "DeleteDataRetentionBotResponse",
});
export const DeleteNetworkRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/networks/{networkId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteNetworkRequest",
});
export const DeleteNetworkResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "DeleteNetworkResponse",
});
export const DeleteSecurityGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    groupId: S.String.pipe(T.HttpLabel("groupId")),
}).pipe(T.all(T.Http({
    method: "DELETE",
    uri: "/networks/{networkId}/security-groups/{groupId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteSecurityGroupRequest",
});
export const DeleteSecurityGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    networkId: S.optional(S.String),
    groupId: S.optional(S.String),
})).annotate({
    identifier: "DeleteSecurityGroupResponse",
});
export const GetBotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    botId: S.String.pipe(T.HttpLabel("botId")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/bots/{botId}" }), svc, auth, proto, ver, rules))).annotate({ identifier: "GetBotRequest" });
export const BotStatus = /*@__PURE__*/ /*#__PURE__*/ S.Literals([1, 2]);
export const GetBotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botId: S.optional(S.String),
    displayName: S.optional(S.String),
    username: S.optional(S.String),
    uname: S.optional(S.String),
    pubkey: S.optional(S.String),
    status: S.optional(BotStatus),
    groupId: S.optional(S.String),
    hasChallenge: S.optional(S.Boolean),
    suspended: S.optional(S.Boolean),
    lastLogin: S.optional(S.String),
})).annotate({ identifier: "GetBotResponse" });
export const GetBotsCountRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/bots/count" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetBotsCountRequest",
});
export const GetBotsCountResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ pending: S.Number, active: S.Number, total: S.Number })).annotate({
    identifier: "GetBotsCountResponse",
});
export const GetDataRetentionBotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({
    method: "GET",
    uri: "/networks/{networkId}/data-retention-bots",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetDataRetentionBotRequest",
});
export const GetDataRetentionBotResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botName: S.optional(S.String),
    botExists: S.optional(S.Boolean),
    isBotActive: S.optional(S.Boolean),
    isDataRetentionBotRegistered: S.optional(S.Boolean),
    isDataRetentionServiceEnabled: S.optional(S.Boolean),
    isPubkeyMsgAcked: S.optional(S.Boolean),
})).annotate({
    identifier: "GetDataRetentionBotResponse",
});
export const GetGuestUserHistoryCountRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({
    method: "GET",
    uri: "/networks/{networkId}/guest-users/count",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetGuestUserHistoryCountRequest",
});
export const GuestUserHistoryCount = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ month: S.String, count: S.String })).annotate({
    identifier: "GuestUserHistoryCount",
});
export const GuestUserHistoryCountList = /*@__PURE__*/ /*#__PURE__*/ S.Array(GuestUserHistoryCount);
export const GetGuestUserHistoryCountResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ history: GuestUserHistoryCountList })).annotate({
    identifier: "GetGuestUserHistoryCountResponse",
});
export const GetNetworkRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetNetworkRequest",
});
export const GetNetworkResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String,
    networkName: S.String,
    accessLevel: AccessLevel,
    awsAccountId: S.String,
    networkArn: S.String,
    standing: S.optional(S.Number),
    freeTrialExpiration: S.optional(S.String),
    migrationState: S.optional(S.Number),
    encryptionKeyArn: S.optional(S.String),
})).annotate({
    identifier: "GetNetworkResponse",
});
export const GetNetworkSettingsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/settings" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetNetworkSettingsRequest",
});
export const Setting = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ optionName: S.String, value: S.String, type: S.String })).annotate({ identifier: "Setting" });
export const SettingsList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Setting);
export const GetNetworkSettingsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ settings: SettingsList })).annotate({
    identifier: "GetNetworkSettingsResponse",
});
export const GetOidcInfoRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    clientId: S.optional(S.String).pipe(T.HttpQuery("clientId")),
    code: S.optional(S.String).pipe(T.HttpQuery("code")),
    grantType: S.optional(S.String).pipe(T.HttpQuery("grantType")),
    redirectUri: S.optional(S.String).pipe(T.HttpQuery("redirectUri")),
    url: S.optional(S.String).pipe(T.HttpQuery("url")),
    clientSecret: S.optional(SensitiveString).pipe(T.HttpQuery("clientSecret")),
    codeVerifier: S.optional(S.String).pipe(T.HttpQuery("codeVerifier")),
    certificate: S.optional(S.String).pipe(T.HttpQuery("certificate")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/oidc" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetOidcInfoRequest",
});
export const OidcConfigInfo = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    applicationName: S.optional(S.String),
    clientId: S.optional(S.String),
    companyId: S.String,
    scopes: S.String,
    issuer: S.String,
    clientSecret: S.optional(SensitiveString),
    secret: S.optional(SensitiveString),
    redirectUrl: S.optional(S.String),
    userId: S.optional(S.String),
    customUsername: S.optional(S.String),
    caCertificate: S.optional(S.String),
    applicationId: S.optional(S.Number),
    ssoTokenBufferMinutes: S.optional(S.Number),
    extraAuthParams: S.optional(S.String),
})).annotate({ identifier: "OidcConfigInfo" });
export const OidcTokenInfo = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    codeVerifier: S.optional(S.String),
    codeChallenge: S.optional(S.String),
    accessToken: S.optional(S.String),
    idToken: S.optional(S.String),
    refreshToken: S.optional(S.String),
    tokenType: S.optional(S.String),
    expiresIn: S.optional(S.Number),
})).annotate({ identifier: "OidcTokenInfo" });
export const GetOidcInfoResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    openidConnectInfo: S.optional(OidcConfigInfo),
    tokenInfo: S.optional(OidcTokenInfo),
})).annotate({
    identifier: "GetOidcInfoResponse",
});
export const GetOpentdfConfigRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/tdf" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetOpentdfConfigRequest",
});
export const GetOpentdfConfigResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    clientId: S.String,
    domain: S.String,
    clientSecret: SensitiveString,
    provider: S.String,
})).annotate({
    identifier: "GetOpentdfConfigResponse",
});
export const GetSecurityGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    groupId: S.String.pipe(T.HttpLabel("groupId")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/networks/{networkId}/security-groups/{groupId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetSecurityGroupRequest",
});
export const GetSecurityGroupResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ securityGroup: SecurityGroup })).annotate({
    identifier: "GetSecurityGroupResponse",
});
export const GetUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    startTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))).pipe(T.HttpQuery("startTime")),
    endTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))).pipe(T.HttpQuery("endTime")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/users/{userId}" }), svc, auth, proto, ver, rules))).annotate({ identifier: "GetUserRequest" });
export const GetUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    userId: S.String,
    firstName: S.optional(SensitiveString),
    lastName: S.optional(SensitiveString),
    username: S.optional(S.String),
    isAdmin: S.optional(S.Boolean),
    suspended: S.optional(S.Boolean),
    status: S.optional(S.Number),
    lastActivity: S.optional(S.Number),
    lastLogin: S.optional(S.Number),
    securityGroupIds: S.optional(SecurityGroupIdList),
})).annotate({
    identifier: "GetUserResponse",
});
export const GetUsersCountRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networkId: S.String.pipe(T.HttpLabel("networkId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/users/count" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetUsersCountRequest",
});
export const GetUsersCountResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    pending: S.Number,
    active: S.Number,
    rejected: S.Number,
    remaining: S.Number,
    total: S.Number,
})).annotate({
    identifier: "GetUsersCountResponse",
});
export const SortDirection = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ListBlockedGuestUsersRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    username: S.optional(S.String).pipe(T.HttpQuery("username")),
    admin: S.optional(S.String).pipe(T.HttpQuery("admin")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/networks/{networkId}/guest-users/blocklist",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListBlockedGuestUsersRequest",
});
export const BlockedGuestUser = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    username: S.String,
    admin: S.String,
    modified: S.String,
    usernameHash: S.String,
})).annotate({
    identifier: "BlockedGuestUser",
});
export const BlockedGuestUserList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BlockedGuestUser);
export const ListBlockedGuestUsersResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    nextToken: S.optional(S.String),
    blocklist: BlockedGuestUserList,
})).annotate({
    identifier: "ListBlockedGuestUsersResponse",
});
export const ListBotsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
    displayName: S.optional(S.String).pipe(T.HttpQuery("displayName")),
    username: S.optional(S.String).pipe(T.HttpQuery("username")),
    status: S.optional(BotStatus).pipe(T.HttpQuery("status")),
    groupId: S.optional(S.String).pipe(T.HttpQuery("groupId")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/bots" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListBotsRequest",
});
export const Bot = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    botId: S.optional(S.String),
    displayName: S.optional(S.String),
    username: S.optional(S.String),
    uname: S.optional(S.String),
    pubkey: S.optional(S.String),
    status: S.optional(BotStatus),
    groupId: S.optional(S.String),
    hasChallenge: S.optional(S.Boolean),
    suspended: S.optional(S.Boolean),
    lastLogin: S.optional(S.String),
})).annotate({ identifier: "Bot" });
export const Bots = /*@__PURE__*/ /*#__PURE__*/ S.Array(Bot);
export const ListBotsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ bots: Bots, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListBotsResponse",
});
export const ListDevicesForUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    userId: S.String.pipe(T.HttpLabel("userId")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/networks/{networkId}/users/{userId}/devices",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDevicesForUserRequest",
});
export const BasicDeviceObject = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    appId: S.optional(S.String),
    created: S.optional(S.String),
    lastLogin: S.optional(S.String),
    statusText: S.optional(S.String),
    suspend: S.optional(S.Boolean),
    type: S.optional(S.String),
})).annotate({
    identifier: "BasicDeviceObject",
});
export const Devices = /*@__PURE__*/ /*#__PURE__*/ S.Array(BasicDeviceObject);
export const ListDevicesForUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ nextToken: S.optional(S.String), devices: Devices })).annotate({
    identifier: "ListDevicesForUserResponse",
});
export const ListGuestUsersRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    username: S.optional(S.String).pipe(T.HttpQuery("username")),
    billingPeriod: S.optional(S.String).pipe(T.HttpQuery("billingPeriod")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/guest-users" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListGuestUsersRequest",
});
export const GuestUser = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    billingPeriod: S.String,
    username: S.String,
    usernameHash: S.String,
})).annotate({ identifier: "GuestUser" });
export const GuestUserList = /*@__PURE__*/ /*#__PURE__*/ S.Array(GuestUser);
export const ListGuestUsersResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ nextToken: S.optional(S.String), guestlist: GuestUserList })).annotate({
    identifier: "ListGuestUsersResponse",
});
export const ListNetworksRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListNetworksRequest",
});
export const Network = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String,
    networkName: S.String,
    accessLevel: AccessLevel,
    awsAccountId: S.String,
    networkArn: S.String,
    standing: S.optional(S.Number),
    freeTrialExpiration: S.optional(S.String),
    migrationState: S.optional(S.Number),
    encryptionKeyArn: S.optional(S.String),
})).annotate({ identifier: "Network" });
export const NetworkList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Network);
export const ListNetworksResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ networks: NetworkList, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListNetworksResponse",
});
export const ListSecurityGroupsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/security-groups" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListSecurityGroupsRequest",
});
export const SecurityGroupList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SecurityGroup);
export const ListSecurityGroupsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    securityGroups: S.optional(SecurityGroupList),
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListSecurityGroupsResponse",
});
export const ListSecurityGroupUsersRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    groupId: S.String.pipe(T.HttpLabel("groupId")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
}).pipe(T.all(T.Http({
    method: "GET",
    uri: "/networks/{networkId}/security-groups/{groupId}/users",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListSecurityGroupUsersRequest",
});
export const ListSecurityGroupUsersResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ users: Users, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListSecurityGroupUsersResponse",
});
export const UserStatus = /*@__PURE__*/ /*#__PURE__*/ S.Literals([1, 2]);
export const ListUsersRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    nextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
    maxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    sortFields: S.optional(S.String).pipe(T.HttpQuery("sortFields")),
    sortDirection: S.optional(SortDirection).pipe(T.HttpQuery("sortDirection")),
    firstName: S.optional(SensitiveString).pipe(T.HttpQuery("firstName")),
    lastName: S.optional(SensitiveString).pipe(T.HttpQuery("lastName")),
    username: S.optional(S.String).pipe(T.HttpQuery("username")),
    status: S.optional(UserStatus).pipe(T.HttpQuery("status")),
    groupId: S.optional(S.String).pipe(T.HttpQuery("groupId")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/networks/{networkId}/users" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListUsersRequest",
});
export const ListUsersResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ nextToken: S.optional(S.String), users: S.optional(Users) })).annotate({
    identifier: "ListUsersResponse",
});
export const RegisterOidcConfigRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    companyId: S.String,
    customUsername: S.optional(S.String),
    extraAuthParams: S.optional(S.String),
    issuer: S.String,
    scopes: S.String,
    secret: S.optional(SensitiveString),
    ssoTokenBufferMinutes: S.optional(S.Number),
    userId: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/networks/{networkId}/oidc/save" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RegisterOidcConfigRequest",
});
export const RegisterOidcConfigResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    applicationName: S.optional(S.String),
    clientId: S.optional(S.String),
    companyId: S.String,
    scopes: S.String,
    issuer: S.String,
    clientSecret: S.optional(SensitiveString),
    secret: S.optional(SensitiveString),
    redirectUrl: S.optional(S.String),
    userId: S.optional(S.String),
    customUsername: S.optional(S.String),
    caCertificate: S.optional(S.String),
    applicationId: S.optional(S.Number),
    ssoTokenBufferMinutes: S.optional(S.Number),
    extraAuthParams: S.optional(S.String),
})).annotate({
    identifier: "RegisterOidcConfigResponse",
});
export const RegisterOidcConfigTestRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    extraAuthParams: S.optional(S.String),
    issuer: S.String,
    scopes: S.String,
    certificate: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/networks/{networkId}/oidc/test" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RegisterOidcConfigTestRequest",
});
export const StringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const RegisterOidcConfigTestResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    tokenEndpoint: S.optional(S.String),
    userinfoEndpoint: S.optional(S.String),
    responseTypesSupported: S.optional(StringList),
    scopesSupported: S.optional(StringList),
    issuer: S.optional(S.String),
    authorizationEndpoint: S.optional(S.String),
    endSessionEndpoint: S.optional(S.String),
    logoutEndpoint: S.optional(S.String),
    grantTypesSupported: S.optional(StringList),
    revocationEndpoint: S.optional(S.String),
    tokenEndpointAuthMethodsSupported: S.optional(StringList),
    microsoftMultiRefreshToken: S.optional(S.Boolean),
})).annotate({
    identifier: "RegisterOidcConfigTestResponse",
});
export const RegisterOpentdfConfigRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    clientId: S.String,
    clientSecret: SensitiveString,
    domain: S.String,
    provider: S.String,
    dryRun: S.optional(S.Boolean).pipe(T.HttpQuery("dryRun")),
}).pipe(T.all(T.Http({ method: "POST", uri: "/networks/{networkId}/tdf" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RegisterOpentdfConfigRequest",
});
export const RegisterOpentdfConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    clientId: S.String,
    domain: S.String,
    clientSecret: SensitiveString,
    provider: S.String,
})).annotate({
    identifier: "RegisterOpentdfConfigResponse",
});
export const UpdateBotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    botId: S.String.pipe(T.HttpLabel("botId")),
    displayName: S.optional(S.String),
    groupId: S.optional(S.String),
    challenge: S.optional(SensitiveString),
    suspend: S.optional(S.Boolean),
}).pipe(T.all(T.Http({ method: "PATCH", uri: "/networks/{networkId}/bots/{botId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateBotRequest",
});
export const UpdateBotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "UpdateBotResponse",
});
export const DataRetentionActionType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const UpdateDataRetentionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    actionType: DataRetentionActionType,
}).pipe(T.all(T.Http({
    method: "PATCH",
    uri: "/networks/{networkId}/data-retention-bots",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateDataRetentionRequest",
});
export const UpdateDataRetentionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "UpdateDataRetentionResponse",
});
export const UpdateGuestUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    usernameHash: S.String.pipe(T.HttpLabel("usernameHash")),
    block: S.Boolean,
}).pipe(T.all(T.Http({
    method: "PATCH",
    uri: "/networks/{networkId}/guest-users/{usernameHash}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateGuestUserRequest",
});
export const UpdateGuestUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "UpdateGuestUserResponse",
});
export const UpdateNetworkRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    networkName: S.String,
    clientToken: S.optional(S.String).pipe(T.HttpHeader("X-Client-Token"), T.IdempotencyToken()),
    encryptionKeyArn: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "PATCH", uri: "/networks/{networkId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateNetworkRequest",
});
export const UpdateNetworkResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ message: S.optional(S.String) })).annotate({
    identifier: "UpdateNetworkResponse",
});
export const Status = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ReadReceiptConfig = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(Status) })).annotate({
    identifier: "ReadReceiptConfig",
});
export const NetworkSettings = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    enableClientMetrics: S.optional(S.Boolean),
    readReceiptConfig: S.optional(ReadReceiptConfig),
    dataRetention: S.optional(S.Boolean),
    enableTrustedDataFormat: S.optional(S.Boolean),
})).annotate({
    identifier: "NetworkSettings",
});
export const UpdateNetworkSettingsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    settings: NetworkSettings,
}).pipe(T.all(T.Http({ method: "PATCH", uri: "/networks/{networkId}/settings" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateNetworkSettingsRequest",
});
export const UpdateNetworkSettingsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ settings: SettingsList })).annotate({
    identifier: "UpdateNetworkSettingsResponse",
});
export const UpdateSecurityGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    groupId: S.String.pipe(T.HttpLabel("groupId")),
    name: S.optional(S.String),
    securityGroupSettings: S.optional(SecurityGroupSettings),
}).pipe(T.all(T.Http({
    method: "PATCH",
    uri: "/networks/{networkId}/security-groups/{groupId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateSecurityGroupRequest",
});
export const UpdateSecurityGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ securityGroup: SecurityGroup })).annotate({
    identifier: "UpdateSecurityGroupResponse",
});
export const UpdateUserDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    firstName: S.optional(SensitiveString),
    lastName: S.optional(SensitiveString),
    username: S.optional(S.String),
    securityGroupIds: S.optional(SecurityGroupIdList),
    inviteCode: S.optional(S.String),
    inviteCodeTtl: S.optional(S.Number),
    codeValidation: S.optional(S.Boolean),
})).annotate({
    identifier: "UpdateUserDetails",
});
export const UpdateUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    networkId: S.String.pipe(T.HttpLabel("networkId")),
    userId: S.String,
    userDetails: S.optional(UpdateUserDetails),
}).pipe(T.all(T.Http({ method: "PATCH", uri: "/networks/{networkId}/users" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateUserRequest",
});
export const UpdateUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    userId: S.String,
    networkId: S.String,
    securityGroupIds: S.optional(SecurityGroupIdList),
    firstName: S.optional(SensitiveString),
    lastName: S.optional(SensitiveString),
    middleName: S.optional(S.String),
    suspended: S.Boolean,
    modified: S.optional(S.Number),
    status: S.optional(S.Number),
    inviteCode: S.optional(S.String),
    inviteExpiration: S.optional(S.Number),
    codeValidation: S.optional(S.Boolean),
})).annotate({
    identifier: "UpdateUserResponse",
});
//# Errors
export class BadRequestError extends S.TaggedErrorClass()("BadRequestError", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class ForbiddenError extends S.TaggedErrorClass()("ForbiddenError", { message: S.optional(S.String) }).pipe(C.withAuthError) {
}
export class InternalServerError extends S.TaggedErrorClass()("InternalServerError", { message: S.String }).pipe(C.withServerError) {
}
export class RateLimitError extends S.TaggedErrorClass()("RateLimitError", { message: S.optional(S.String) }).pipe(C.withThrottlingError) {
}
export class ResourceNotFoundError extends S.TaggedErrorClass()("ResourceNotFoundError", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class UnauthorizedError extends S.TaggedErrorClass()("UnauthorizedError", { message: S.optional(S.String) }).pipe(C.withAuthError) {
}
export class ValidationError extends S.TaggedErrorClass()("ValidationError", { reasons: S.optional(ErrorDetailList), message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
/**
 * 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 const batchCreateUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchCreateUserRequest,
    output: BatchCreateUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Deletes multiple users from a specified Wickr network. This operation permanently removes user accounts and their associated data from the network.
 */
export const batchDeleteUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchDeleteUserRequest,
    output: BatchDeleteUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const batchLookupUserUname = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchLookupUserUnameRequest,
    output: BatchLookupUserUnameResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const batchReinviteUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchReinviteUserRequest,
    output: BatchReinviteUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const batchResetDevicesForUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchResetDevicesForUserRequest,
    output: BatchResetDevicesForUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const batchToggleUserSuspendStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchToggleUserSuspendStatusRequest,
    output: BatchToggleUserSuspendStatusResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const createBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateBotRequest,
    output: CreateBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const createDataRetentionBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateDataRetentionBotRequest,
    output: CreateDataRetentionBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Creates a new challenge password for the data retention bot. This password is used for authentication when the bot connects to the network.
 */
export const createDataRetentionBotChallenge = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateDataRetentionBotChallengeRequest,
    output: CreateDataRetentionBotChallengeResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Creates a new Wickr network with specified access level and configuration. This operation provisions a new communication network for your organization.
 */
export const createNetwork = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateNetworkRequest,
    output: CreateNetworkResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const createSecurityGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateSecurityGroupRequest,
    output: CreateSecurityGroupResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Deletes a bot from a specified Wickr network. This operation permanently removes the bot account and its associated data from the network.
 */
export const deleteBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteBotRequest,
    output: DeleteBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Deletes the data retention bot from a Wickr network. This operation permanently removes the bot and all its associated data from the database.
 */
export const deleteDataRetentionBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteDataRetentionBotRequest,
    output: DeleteDataRetentionBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const deleteNetwork = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteNetworkRequest,
    output: DeleteNetworkResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Deletes a security group from a Wickr network. This operation cannot be performed on the default security group.
 */
export const deleteSecurityGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteSecurityGroupRequest,
    output: DeleteSecurityGroupResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves detailed information about a specific bot in a Wickr network, including its status, group membership, and authentication details.
 */
export const getBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetBotRequest,
    output: GetBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves the count of bots in a Wickr network, categorized by their status (pending, active, and total).
 */
export const getBotsCount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetBotsCountRequest,
    output: GetBotsCountResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves information about the data retention bot in a Wickr network, including its status and whether the data retention service is enabled.
 */
export const getDataRetentionBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetDataRetentionBotRequest,
    output: GetDataRetentionBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const getGuestUserHistoryCount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetGuestUserHistoryCountRequest,
    output: GetGuestUserHistoryCountResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves detailed information about a specific Wickr network, including its configuration, access level, and status.
 */
export const getNetwork = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetNetworkRequest,
    output: GetNetworkResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves all network-level settings for a Wickr network, including client metrics, data retention, and other configuration options.
 */
export const getNetworkSettings = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetNetworkSettingsRequest,
    output: GetNetworkSettingsResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves the OpenID Connect (OIDC) configuration for a Wickr network, including SSO settings and optional token information if access token parameters are provided.
 */
export const getOidcInfo = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetOidcInfoRequest,
    output: GetOidcInfoResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves the OpenTDF integration configuration for a Wickr network.
 */
export const getOpentdfConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetOpentdfConfigRequest,
    output: GetOpentdfConfigResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves detailed information about a specific security group in a Wickr network, including its settings, member counts, and configuration.
 */
export const getSecurityGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetSecurityGroupRequest,
    output: GetSecurityGroupResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves detailed information about a specific user in a Wickr network, including their profile, status, and activity history.
 */
export const getUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetUserRequest,
    output: GetUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const getUsersCount = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetUsersCountRequest,
    output: GetUsersCountResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Retrieves a paginated list of guest users who have been blocked from a Wickr network. You can filter and sort the results.
 */
export const listBlockedGuestUsers = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListBlockedGuestUsersRequest,
    output: ListBlockedGuestUsersResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "blocklist",
        pageSize: "maxResults",
    },
}));
/**
 * Retrieves a paginated list of bots in a specified Wickr network. You can filter and sort the results based on various criteria.
 */
export const listBots = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListBotsRequest,
    output: ListBotsResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "bots",
        pageSize: "maxResults",
    },
}));
/**
 * 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 const listDevicesForUser = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListDevicesForUserRequest,
    output: ListDevicesForUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "devices",
        pageSize: "maxResults",
    },
}));
/**
 * 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 const listGuestUsers = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListGuestUsersRequest,
    output: ListGuestUsersResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "guestlist",
        pageSize: "maxResults",
    },
}));
/**
 * 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 const listNetworks = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListNetworksRequest,
    output: ListNetworksResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "networks",
        pageSize: "maxResults",
    },
}));
/**
 * Retrieves a paginated list of security groups in a specified Wickr network. You can sort the results by various criteria.
 */
export const listSecurityGroups = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListSecurityGroupsRequest,
    output: ListSecurityGroupsResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "securityGroups",
        pageSize: "maxResults",
    },
}));
/**
 * Retrieves a paginated list of users who belong to a specific security group in a Wickr network.
 */
export const listSecurityGroupUsers = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListSecurityGroupUsersRequest,
    output: ListSecurityGroupUsersResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "users",
        pageSize: "maxResults",
    },
}));
/**
 * 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 const listUsers = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListUsersRequest,
    output: ListUsersResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "users",
        pageSize: "maxResults",
    },
}));
/**
 * Registers and saves an OpenID Connect (OIDC) configuration for a Wickr network, enabling Single Sign-On (SSO) authentication through an identity provider.
 */
export const registerOidcConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RegisterOidcConfigRequest,
    output: RegisterOidcConfigResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Tests an OpenID Connect (OIDC) configuration for a Wickr network by validating the connection to the identity provider and retrieving its supported capabilities.
 */
export const registerOidcConfigTest = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RegisterOidcConfigTestRequest,
    output: RegisterOidcConfigTestResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Registers and saves OpenTDF configuration for a Wickr network, enabling attribute-based access control for Wickr through an OpenTDF provider.
 */
export const registerOpentdfConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RegisterOpentdfConfigRequest,
    output: RegisterOpentdfConfigResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const updateBot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateBotRequest,
    output: UpdateBotResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Updates the data retention bot settings, allowing you to enable or disable the data retention service, or acknowledge the public key message.
 */
export const updateDataRetention = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateDataRetentionRequest,
    output: UpdateDataRetentionResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const updateGuestUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateGuestUserRequest,
    output: UpdateGuestUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Updates the properties of an existing Wickr network, such as its name or encryption key configuration.
 */
export const updateNetwork = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateNetworkRequest,
    output: UpdateNetworkResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Updates network-level settings for a Wickr network. You can modify settings such as client metrics, data retention, and other network-wide options.
 */
export const updateNetworkSettings = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateNetworkSettingsRequest,
    output: UpdateNetworkSettingsResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * Updates the properties of an existing security group in a Wickr network, such as its name or settings.
 */
export const updateSecurityGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateSecurityGroupRequest,
    output: UpdateSecurityGroupResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
/**
 * 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 const updateUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateUserRequest,
    output: UpdateUserResponse,
    errors: [
        BadRequestError,
        ForbiddenError,
        InternalServerError,
        RateLimitError,
        ResourceNotFoundError,
        UnauthorizedError,
        ValidationError,
    ],
}));
//# sourceMappingURL=wickr.js.map