Class: Aws::Wickr::Client

Inherits:
Seahorse::Client::Base show all
Includes:
ClientStubs
Defined in:
gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb

Overview

An API client for Wickr. To construct a client, you need to configure a :region and :credentials.

client = Aws::Wickr::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the developer guide.

See #initialize for a full list of supported configuration options.

Instance Attribute Summary

Attributes inherited from Seahorse::Client::Base

#config, #handlers

API Operations collapse

Instance Method Summary collapse

Methods included from ClientStubs

#api_requests, #stub_data, #stub_responses

Methods inherited from Seahorse::Client::Base

add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins

Methods included from Seahorse::Client::HandlerBuilder

#handle, #handle_request, #handle_response

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials used for authentication. This can be any class that includes and implements Aws::CredentialProvider, or instance of any one of the following classes:

    • Aws::Credentials - Used for configuring static, non-refreshing credentials.

    • Aws::SharedCredentials - Used for loading static credentials from a shared file, such as ~/.aws/config.

    • Aws::AssumeRoleCredentials - Used when you need to assume a role.

    • Aws::AssumeRoleWebIdentityCredentials - Used when you need to assume a role after providing credentials via the web.

    • Aws::SSOCredentials - Used for loading credentials from AWS SSO using an access token generated from aws login.

    • Aws::ProcessCredentials - Used for loading credentials from a process that outputs to stdout.

    • Aws::InstanceProfileCredentials - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • Aws::ECSCredentials - Used for loading credentials from instances running in ECS.

    • Aws::CognitoIdentityCredentials - Used for loading credentials from the Cognito Identity service.

    When :credentials are not configured directly, the following locations will be searched for credentials:

    • Aws.config[:credentials]

    • The :access_key_id, :secret_access_key, :session_token, and :account_id options.

    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID'].

    • ~/.aws/credentials

    • ~/.aws/config

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of Aws::InstanceProfileCredentials or Aws::ECSCredentials to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED'] to true.

  • :region (required, String) —

    The AWS region to connect to. The configured :region is used to determine the service :endpoint. When not passed, a default :region is searched for in the following locations:

    • Aws.config[:region]
    • ENV['AWS_REGION']
    • ENV['AMAZON_REGION']
    • ENV['AWS_DEFAULT_REGION']
    • ~/.aws/credentials
    • ~/.aws/config
  • :access_key_id (String)
  • :account_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to true, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to false.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in adaptive retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a RetryCapacityNotAvailableError and will not retry instead of sleeping.

  • :auth_scheme_preference (Array<String>) —

    A list of preferred authentication schemes to use when making a request. Supported values are: sigv4, sigv4a, httpBearerAuth, and noAuth. When set using ENV['AWS_AUTH_SCHEME_PREFERENCE'] or in shared config as auth_scheme_preference, the value should be a comma-separated list.

  • :client_side_monitoring (Boolean) — default: false —

    When true, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When true, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in standard and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks. Takes effect only when disable_clock_skew_correction is not set.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_clock_skew_correction (Boolean) —

    Used only in standard and adaptive retry modes. When true, the SDK does not apply a clock skew correction, does not update its stored skew from responses, and does not retry clock skew errors. Clock skew correction is enabled by default.

  • :disable_host_prefix_injection (Boolean) — default: false —

    When true, the SDK will not prepend the modeled host prefix to the endpoint.

  • :disable_request_compression (Boolean) — default: false —

    When set to 'true' the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the :endpoint option directly. This is normally constructed from the :region option. Configuring :endpoint is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to true, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the :logger at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in standard and adaptive retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, 'default' is used.

  • :request_checksum_calculation (String) — default: "when_supported" —

    Determines when a checksum will be calculated for request payloads. Values are:

    • when_supported - (default) When set, a checksum will be calculated for all request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true and/or a requestAlgorithmMember is modeled.
    • when_required - When set, a checksum will only be calculated for request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true or where a requestAlgorithmMember is modeled and supplied.
  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :response_checksum_validation (String) — default: "when_supported" —

    Determines when checksum validation will be performed on response payloads. Values are:

    • when_supported - (default) When set, checksum validation is performed on all response payloads of operations modeled with the httpChecksum trait where responseAlgorithms is modeled, except when no modeled checksum algorithms are supported.
    • when_required - When set, checksum validation is not performed on response payloads of operations unless the checksum algorithm is supported and the requestValidationModeMember member is set to ENABLED.
  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the legacy retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the legacy retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the legacy retry mode.

    @see https://www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the legacy retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the legacy retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • legacy - The pre-existing retry behavior. This is the default value if no retry mode is provided.

    • standard - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • adaptive - A retry mode that includes all the functionality of standard mode along with automatic client side throttling.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default :sigv4a_signing_region_set is searched for in the following locations:

    • Aws.config[:sigv4a_signing_region_set]
    • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
    • ~/.aws/config
  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    Please note When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses NoOpTelemetryProvider which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the opentelemetry-sdk gem and then, pass in an instance of a Aws::Telemetry::OTelProvider for telemetry provider.
  • :token_provider (Aws::TokenProvider) —

    Your Bearer token used for authentication. This can be any class that includes and implements Aws::TokenProvider, or instance of any one of the following classes:

    • Aws::StaticTokenProvider - Used for configuring static, non-refreshing tokens.

    • Aws::SSOTokenProvider - Used for loading tokens from AWS SSO using an access token generated from aws login.

    When :token_provider is not configured directly, the Aws::TokenProviderChain will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to true, dualstack enabled endpoints (with .aws TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to true, fips compatible endpoints will be used if available. When a fips region is used, the region is normalized and this config is set to true.

  • :validate_params (Boolean) — default: true —

    When true, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::Wickr::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to #resolve_endpoint(parameters) where parameters is a Struct similar to Aws::Wickr::EndpointParameters.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has "Expect" header set to "100-continue". Defaults to nil which disables this behaviour. This value can safely be set per request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_open_timeout (Float) — default: 15 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like 'http://proxy.com:123'.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_wire_trace (Boolean) — default: false —

    When true, HTTP debug output will be sent to the :logger.

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a content-length).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When true, response errors are raised.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass :ssl_ca_bundle or :ssl_ca_directory the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass :ssl_ca_bundle or :ssl_ca_directory the the system default will be used if available.

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

    When true, SSL peer certificates are verified when establishing a connection.



478
479
480
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 478

def initialize(*args)
  super
end

Instance Method Details

#batch_create_user(params = {}) ⇒ Types::BatchCreateUserResponse

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.

Examples:

Example: Create multiple users


resp = client.batch_create_user({
  client_token: "550e8400-e29b-41d4-a716-446655440000", 
  network_id: "12345678", 
  users: [
    {
      code_validation: true, 
      first_name: "John", 
      invite_code: "INVITE123", 
      invite_code_ttl: 7, 
      last_name: "Doe", 
      security_group_ids: [
        "BCTY8Qhe", 
      ], 
      username: "john.doe@example.com", 
    }, 
    {
      first_name: "Jane", 
      last_name: "Smith", 
      security_group_ids: [
        "BCTY8Qhe", 
      ], 
      username: "jane.smith@example.com", 
    }, 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
  ], 
  successful: [
    {
      code_validation: true, 
      first_name: "John", 
      invite_code: "INVITE123", 
      is_invite_expired: false, 
      last_name: "Doe", 
      status: 1, 
      user_id: "123", 
      username: "john.doe@example.com", 
    }, 
    {
      code_validation: false, 
      first_name: "Jane", 
      invite_code: "AUTOGEN456", 
      is_invite_expired: false, 
      last_name: "Smith", 
      status: 1, 
      user_id: "456", 
      username: "jane.smith@example.com", 
    }, 
  ], 
}

Example: Partial failure - duplicate user


resp = client.batch_create_user({
  network_id: "12345678", 
  users: [
    {
      first_name: "Alice", 
      last_name: "Johnson", 
      security_group_ids: [
        "BCTY8Qhe", 
      ], 
      username: "alice.johnson@example.com", 
    }, 
    {
      first_name: "Bob", 
      last_name: "Wilson", 
      security_group_ids: [
        "BCTY8Qhe", 
      ], 
      username: "existing.user@example.com", 
    }, 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
    {
      field: "username", 
      reason: "User already exists", 
      user_id: "0", 
    }, 
  ], 
  successful: [
    {
      code_validation: false, 
      first_name: "Alice", 
      invite_code: "AUTOGEN789", 
      is_invite_expired: false, 
      last_name: "Johnson", 
      status: 1, 
      user_id: "678", 
      username: "alice.johnson@example.com", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.batch_create_user({
  network_id: "NetworkId", # required
  users: [ # required
    {
      first_name: "SensitiveString",
      last_name: "SensitiveString",
      security_group_ids: ["SecurityGroupId"], # required
      username: "GenericString", # required
      invite_code: "GenericString",
      invite_code_ttl: 1,
      code_validation: false,
    },
  ],
  client_token: "ClientToken",
})

Response structure


resp.message #=> String
resp.successful #=> Array
resp.successful[0].user_id #=> String
resp.successful[0].first_name #=> String
resp.successful[0].last_name #=> String
resp.successful[0].username #=> String
resp.successful[0].security_groups #=> Array
resp.successful[0].security_groups[0] #=> String
resp.successful[0].is_admin #=> Boolean
resp.successful[0].suspended #=> Boolean
resp.successful[0].status #=> Integer
resp.successful[0].otp_enabled #=> Boolean
resp.successful[0].scim_id #=> String
resp.successful[0].type #=> String
resp.successful[0].cell #=> String
resp.successful[0].country_code #=> String
resp.successful[0].challenge_failures #=> Integer
resp.successful[0].is_invite_expired #=> Boolean
resp.successful[0].is_user #=> Boolean
resp.successful[0].invite_code #=> String
resp.successful[0].code_validation #=> Boolean
resp.successful[0].uname #=> String
resp.failed #=> Array
resp.failed[0].field #=> String
resp.failed[0].reason #=> String
resp.failed[0].user_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where users will be created.

  • :users (required, Array<Types::BatchCreateUserRequestItem>) —

    A list of user objects containing the details for each user to be created, including username, name, security groups, and optional invite codes. Maximum 50 users per batch request.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency. If you retry a request with the same client token, the service will return the same response without creating duplicate users.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



671
672
673
674
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 671

def batch_create_user(params = {}, options = {})
  req = build_request(:batch_create_user, params)
  req.send_request(options)
end

#batch_delete_user(params = {}) ⇒ Types::BatchDeleteUserResponse

Deletes multiple users from a specified Wickr network. This operation permanently removes user accounts and their associated data from the network.

Examples:

Example: Delete multiple users


resp = client.batch_delete_user({
  client_token: "6ba7b814-9dad-11d1-80b4-00c04fd430c8", 
  network_id: "12345678", 
  user_ids: [
    "123", 
    "456", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
  ], 
  message: "success", 
  successful: [
    {
      user_id: "123", 
    }, 
    {
      user_id: "456", 
    }, 
  ], 
}

Example: Partial failure - user not found


resp = client.batch_delete_user({
  network_id: "12345678", 
  user_ids: [
    "123", 
    "456", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
    {
      field: "username", 
      reason: "User not found", 
      user_id: "456", 
    }, 
  ], 
  message: "partial success", 
  successful: [
    {
      user_id: "123", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.batch_delete_user({
  network_id: "NetworkId", # required
  user_ids: ["UserId"], # required
  client_token: "ClientToken",
})

Response structure


resp.message #=> String
resp.successful #=> Array
resp.successful[0].user_id #=> String
resp.failed #=> Array
resp.failed[0].field #=> String
resp.failed[0].reason #=> String
resp.failed[0].user_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which users will be deleted.

  • :user_ids (required, Array<String>) —

    A list of user IDs identifying the users to be deleted from the network. Maximum 50 users per batch request.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency. If you retry a request with the same client token, the service will return the same response without attempting to delete users again.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



777
778
779
780
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 777

def batch_delete_user(params = {}, options = {})
  req = build_request(:batch_delete_user, params)
  req.send_request(options)
end

#batch_lookup_user_uname(params = {}) ⇒ Types::BatchLookupUserUnameResponse

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.

Examples:

Example: Lookup multiple user unames


resp = client.batch_lookup_user_uname({
  client_token: "f47ac10b-58cc-4372-a567-0e02b2c3d479", 
  network_id: "12345678", 
  unames: [
    "a1b2c3d4e5f6", 
    "g7h8i9j0k1l2", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
  ], 
  message: "success", 
  successful: [
    {
      uname: "a1b2c3d4e5f6", 
      username: "john.doe@example.com", 
    }, 
    {
      uname: "g7h8i9j0k1l2", 
      username: "john.doe2@example.com", 
    }, 
  ], 
}

Example: Partial failure - uname not found


resp = client.batch_lookup_user_uname({
  network_id: "12345678", 
  unames: [
    "a1b2c3d4e5f6", 
    "invaliduname", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
    {
      field: "uname", 
      reason: "Uname not found", 
      uname: "invaliduname", 
    }, 
  ], 
  message: "partial success", 
  successful: [
    {
      uname: "a1b2c3d4e5f6", 
      username: "john.doe@example.com", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.batch_lookup_user_uname({
  network_id: "NetworkId", # required
  unames: ["GenericString"], # required
  client_token: "ClientToken",
})

Response structure


resp.message #=> String
resp.successful #=> Array
resp.successful[0].uname #=> String
resp.successful[0].username #=> String
resp.failed #=> Array
resp.failed[0].field #=> String
resp.failed[0].reason #=> String
resp.failed[0].uname #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where the users will be looked up.

  • :unames (required, Array<String>) —

    A list of username hashes (unames) to look up. Each uname is a unique identifier for a user's username. Maximum 50 unames per batch request.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



886
887
888
889
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 886

def batch_lookup_user_uname(params = {}, options = {})
  req = build_request(:batch_lookup_user_uname, params)
  req.send_request(options)
end

#batch_reinvite_user(params = {}) ⇒ Types::BatchReinviteUserResponse

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.

Examples:

Example: Batch reinvite users successfully


resp = client.batch_reinvite_user({
  network_id: "12345678", 
  user_ids: [
    "12345", 
    "67890", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
  ], 
  successful: [
    {
      user_id: "12345", 
    }, 
    {
      user_id: "67890", 
    }, 
  ], 
}

Example: Batch reinvite users - partial success


resp = client.batch_reinvite_user({
  network_id: "12345678", 
  user_ids: [
    "12345", 
    "99999", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
    {
      reason: "user not found in current network", 
      user_id: "99999", 
    }, 
  ], 
  successful: [
    {
      user_id: "12345", 
    }, 
  ], 
}

Example: Batch reinvite users - cannot reinvite


resp = client.batch_reinvite_user({
  network_id: "12345678", 
  user_ids: [
    "54321", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
    {
      reason: "user cannot be reinvited", 
      user_id: "54321", 
    }, 
  ], 
  successful: [
  ], 
}

Request syntax with placeholder values


resp = client.batch_reinvite_user({
  network_id: "NetworkId", # required
  user_ids: ["UserId"], # required
  client_token: "ClientToken",
})

Response structure


resp.message #=> String
resp.successful #=> Array
resp.successful[0].user_id #=> String
resp.failed #=> Array
resp.failed[0].field #=> String
resp.failed[0].reason #=> String
resp.failed[0].user_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where users will be reinvited.

  • :user_ids (required, Array<String>) —

    A list of user IDs identifying the users to be reinvited to the network. Maximum 50 users per batch request.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



1008
1009
1010
1011
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1008

def batch_reinvite_user(params = {}, options = {})
  req = build_request(:batch_reinvite_user, params)
  req.send_request(options)
end

#batch_reset_devices_for_user(params = {}) ⇒ Types::BatchResetDevicesForUserResponse

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.

Examples:

Example: Successful device reset


resp = client.batch_reset_devices_for_user({
  app_ids: [
    "d3135a42dcb6437780b16c3ca9581fe64e6822773cd6b965d25fc9929c89aca6", 
    "e4246b53edc7548891c27d4da0692fe75f7933884de7c076e36gca030d90bdb7", 
  ], 
  network_id: "12345678", 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  failed: [
  ], 
  message: "success", 
  successful: [
    {
      app_id: "d3135a42dcb6437780b16c3ca9581fe64e6822773cd6b965d25fc9929c89aca6", 
    }, 
    {
      app_id: "e4246b53edc7548891c27d4da0692fe75f7933884de7c076e36gca030d90bdb7", 
    }, 
  ], 
}

Example: Partial failure device reset


resp = client.batch_reset_devices_for_user({
  app_ids: [
    "d3135a42dcb6437780b16c3ca9581fe64e6822773cd6b965d25fc9929c89aca6", 
    "invalid-app-id", 
  ], 
  network_id: "12345678", 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  failed: [
    {
      app_id: "invalid-app-id", 
      field: "appId", 
      reason: "Invalid app ID.", 
    }, 
  ], 
  message: "partial success", 
  successful: [
    {
      app_id: "d3135a42dcb6437780b16c3ca9581fe64e6822773cd6b965d25fc9929c89aca6", 
    }, 
  ], 
}

Example: Invalid network ID error


resp = client.batch_reset_devices_for_user({
  app_ids: [
    "d3135a42dcb6437780b16c3ca9581fe64e6822773cd6b965d25fc9929c89aca6", 
  ], 
  network_id: "00000000", 
  user_id: "12345", 
})

Request syntax with placeholder values


resp = client.batch_reset_devices_for_user({
  network_id: "NetworkId", # required
  user_id: "UserId", # required
  app_ids: ["GenericString"], # required
  client_token: "ClientToken",
})

Response structure


resp.message #=> String
resp.successful #=> Array
resp.successful[0].app_id #=> String
resp.failed #=> Array
resp.failed[0].field #=> String
resp.failed[0].reason #=> String
resp.failed[0].app_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the user whose devices will be reset.

  • :user_id (required, String) —

    The ID of the user whose devices will be reset.

  • :app_ids (required, Array<String>) —

    A list of application IDs identifying the specific devices to be reset for the user. Maximum 50 devices per batch request.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



1129
1130
1131
1132
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1129

def batch_reset_devices_for_user(params = {}, options = {})
  req = build_request(:batch_reset_devices_for_user, params)
  req.send_request(options)
end

#batch_toggle_user_suspend_status(params = {}) ⇒ Types::BatchToggleUserSuspendStatusResponse

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.

Examples:

Example: Suspend multiple users


resp = client.batch_toggle_user_suspend_status({
  client_token: "6ba7b815-9dad-11d1-80b4-00c04fd430c8", 
  network_id: "12345678", 
  suspend: true, 
  user_ids: [
    "123", 
    "456", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
  ], 
  message: "success", 
  successful: [
    {
      user_id: "123", 
    }, 
    {
      user_id: "456", 
    }, 
  ], 
}

Example: Unsuspend users with partial failure


resp = client.batch_toggle_user_suspend_status({
  network_id: "12345678", 
  suspend: false, 
  user_ids: [
    "123", 
    "456", 
  ], 
})

resp.to_h outputs the following:
{
  failed: [
    {
      field: "username", 
      reason: "User not found", 
      user_id: "456", 
    }, 
  ], 
  message: "partial success", 
  successful: [
    {
      user_id: "123", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.batch_toggle_user_suspend_status({
  network_id: "NetworkId", # required
  suspend: false, # required
  user_ids: ["UserId"], # required
  client_token: "ClientToken",
})

Response structure


resp.message #=> String
resp.successful #=> Array
resp.successful[0].user_id #=> String
resp.failed #=> Array
resp.failed[0].field #=> String
resp.failed[0].reason #=> String
resp.failed[0].user_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where users will be suspended or unsuspended.

  • :suspend (required, Boolean) —

    A boolean value indicating whether to suspend (true) or unsuspend (false) the specified users.

  • :user_ids (required, Array<String>) —

    A list of user IDs identifying the users whose suspend status will be toggled. Maximum 50 users per batch request.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



1242
1243
1244
1245
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1242

def batch_toggle_user_suspend_status(params = {}, options = {})
  req = build_request(:batch_toggle_user_suspend_status, params)
  req.send_request(options)
end

#create_bot(params = {}) ⇒ Types::CreateBotResponse

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.

Examples:

Example: Create bot successfully


resp = client.create_bot({
  challenge: "SecureP@ssw0rd123", 
  display_name: "Analytics Bot", 
  group_id: "analytics_group", 
  network_id: "12345678", 
  username: "analytics_bot", 
})

resp.to_h outputs the following:
{
  bot_id: "98766", 
  display_name: "Analytics Bot", 
  group_id: "analytics_group", 
  network_id: "12345678", 
  username: "analytics_bot", 
}

Example: Create bot - username unavailable


resp = client.create_bot({
  challenge: "SecureP@ssw0rd123", 
  display_name: "Support Bot", 
  group_id: "default_group", 
  network_id: "12345678", 
  username: "support_bot", 
})

Example: Create bot - invalid username format


resp = client.create_bot({
  challenge: "SecureP@ssw0rd123", 
  display_name: "Test Bot", 
  group_id: "default_group", 
  network_id: "12345678", 
  username: "bot@invalid", 
})

Request syntax with placeholder values


resp = client.create_bot({
  network_id: "NetworkId", # required
  username: "GenericString", # required
  display_name: "GenericString",
  group_id: "GenericString", # required
  challenge: "SensitiveString", # required
})

Response structure


resp.message #=> String
resp.bot_id #=> String
resp.network_id #=> String
resp.username #=> String
resp.display_name #=> String
resp.group_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where the bot will be created.

  • :username (required, String) —

    The username for the bot. This must be unique within the network and follow the network's naming conventions.

  • :display_name (String) —

    The display name for the bot that will be visible to users in the network.

  • :group_id (required, String) —

    The ID of the security group to which the bot will be assigned.

  • :challenge (required, String) —

    The password for the bot account.

Returns:

See Also:



1340
1341
1342
1343
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1340

def create_bot(params = {}, options = {})
  req = build_request(:create_bot, params)
  req.send_request(options)
end

#create_data_retention_bot(params = {}) ⇒ Types::CreateDataRetentionBotResponse

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.

Examples:

Example: Create data retention bot successfully


resp = client.create_data_retention_bot({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "successfully provisioned data retention bot", 
}

Example: Create data retention bot - users already exist


resp = client.create_data_retention_bot({
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.create_data_retention_bot({
  network_id: "NetworkId", # required
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where the data retention bot will be created.

Returns:

See Also:



1390
1391
1392
1393
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1390

def create_data_retention_bot(params = {}, options = {})
  req = build_request(:create_data_retention_bot, params)
  req.send_request(options)
end

#create_data_retention_bot_challenge(params = {}) ⇒ Types::CreateDataRetentionBotChallengeResponse

Creates a new challenge password for the data retention bot. This password is used for authentication when the bot connects to the network.

Examples:

Example: Create data retention bot challenge successfully


resp = client.create_data_retention_bot_challenge({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  challenge: "a1b2c3d4e5f6", 
}

Request syntax with placeholder values


resp = client.create_data_retention_bot_challenge({
  network_id: "NetworkId", # required
})

Response structure


resp.challenge #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the data retention bot.

Returns:

See Also:



1432
1433
1434
1435
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1432

def create_data_retention_bot_challenge(params = {}, options = {})
  req = build_request(:create_data_retention_bot_challenge, params)
  req.send_request(options)
end

#create_network(params = {}) ⇒ Types::CreateNetworkResponse

Creates a new Wickr network with specified access level and configuration. This operation provisions a new communication network for your organization.

Examples:

Example: Create network successfully


resp = client.create_network({
  access_level: "PREMIUM", 
  enable_premium_free_trial: false, 
  network_name: "Production Network", 
})

resp.to_h outputs the following:
{
  network_id: "12345678", 
  network_name: "Production Network", 
}

Example: Create network with free trial


resp = client.create_network({
  access_level: "PREMIUM", 
  enable_premium_free_trial: true, 
  network_name: "Trial Network", 
})

resp.to_h outputs the following:
{
  network_id: "87654321", 
  network_name: "Trial Network", 
}

Example: Create network - invalid name


resp = client.create_network({
  access_level: "STANDARD", 
  network_name: "This network name is way too long", 
})

Request syntax with placeholder values


resp = client.create_network({
  network_name: "GenericString", # required
  access_level: "STANDARD", # required, accepts STANDARD, PREMIUM
  enable_premium_free_trial: false,
  encryption_key_arn: "GenericString",
})

Response structure


resp.network_id #=> String
resp.network_name #=> String
resp.encryption_key_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_name (required, String) —

    The name for the new network. Must be between 1 and 20 characters.

  • :access_level (required, String) —

    The access level for the network. Valid values are STANDARD or PREMIUM, which determine the features and capabilities available to network members.

  • :enable_premium_free_trial (Boolean) —

    Specifies whether to enable a premium free trial for the network. It is optional and has a default value as false. When set to true, the network starts with premium features for a limited trial period.

  • :encryption_key_arn (String) —

    The ARN of the Amazon Web Services KMS customer managed key to use for encrypting sensitive data in the network.

Returns:

See Also:



1519
1520
1521
1522
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1519

def create_network(params = {}, options = {})
  req = build_request(:create_network, params)
  req.send_request(options)
end

#create_security_group(params = {}) ⇒ Types::CreateSecurityGroupResponse

Creates a new security group in a Wickr network. Security groups allow you to organize users and control their permissions, features, and security settings.

Examples:

Example: Create security group successfully


resp = client.create_security_group({
  name: "engineering", 
  network_id: "12345678", 
  security_group_settings: {
    federation_mode: 1, 
    lockout_threshold: 10, 
  }, 
})

resp.to_h outputs the following:
{
  security_group: {
    name: "engineering", 
    active_members: 0, 
    bot_members: 0, 
    id: "def67890", 
    is_default: false, 
    modified: 1638360000, 
    security_group_settings: {
      federation_mode: 1, 
      lockout_threshold: 10, 
    }, 
  }, 
}

Example: Create security group - missing name


resp = client.create_security_group({
  name: "", 
  network_id: "12345678", 
  security_group_settings: {
    federation_mode: 1, 
  }, 
})

Request syntax with placeholder values


resp = client.create_security_group({
  network_id: "NetworkId", # required
  name: "GenericString", # required
  security_group_settings: { # required
    lockout_threshold: 1,
    permitted_networks: ["NetworkId"],
    enable_guest_federation: false,
    global_federation: false,
    federation_mode: 1,
    enable_restricted_global_federation: false,
    permitted_wickr_aws_networks: [
      {
        region: "GenericString", # required
        network_id: "NetworkId", # required
      },
    ],
    permitted_wickr_enterprise_networks: [
      {
        domain: "GenericString", # required
        network_id: "NetworkId", # required
      },
    ],
  },
  client_token: "ClientToken",
})

Response structure


resp.security_group.active_members #=> Integer
resp.security_group.bot_members #=> Integer
resp.security_group.active_directory_guid #=> String
resp.security_group.id #=> String
resp.security_group.is_default #=> Boolean
resp.security_group.name #=> String
resp.security_group.modified #=> Integer
resp.security_group.security_group_settings.always_reauthenticate #=> Boolean
resp.security_group.security_group_settings.atak_package_values #=> Array
resp.security_group.security_group_settings.atak_package_values[0] #=> String
resp.security_group.security_group_settings.calling.can_start_11_call #=> Boolean
resp.security_group.security_group_settings.calling.can_video_call #=> Boolean
resp.security_group.security_group_settings.calling.force_tcp_call #=> Boolean
resp.security_group.security_group_settings.check_for_updates #=> Boolean
resp.security_group.security_group_settings.enable_atak #=> Boolean
resp.security_group.security_group_settings.enable_crash_reports #=> Boolean
resp.security_group.security_group_settings.enable_file_download #=> Boolean
resp.security_group.security_group_settings.enable_guest_federation #=> Boolean
resp.security_group.security_group_settings.enable_notification_preview #=> Boolean
resp.security_group.security_group_settings.enable_open_access_option #=> Boolean
resp.security_group.security_group_settings.enable_restricted_global_federation #=> Boolean
resp.security_group.security_group_settings.files_enabled #=> Boolean
resp.security_group.security_group_settings.force_device_lockout #=> Integer
resp.security_group.security_group_settings.force_open_access #=> Boolean
resp.security_group.security_group_settings.force_read_receipts #=> Boolean
resp.security_group.security_group_settings.global_federation #=> Boolean
resp.security_group.security_group_settings.is_ato_enabled #=> Boolean
resp.security_group.security_group_settings.is_link_preview_enabled #=> Boolean
resp.security_group.security_group_settings.location_allow_maps #=> Boolean
resp.security_group.security_group_settings.location_enabled #=> Boolean
resp.security_group.security_group_settings.max_auto_download_size #=> Integer
resp.security_group.security_group_settings.max_bor #=> Integer
resp.security_group.security_group_settings.max_ttl #=> Integer
resp.security_group.security_group_settings.message_forwarding_enabled #=> Boolean
resp.security_group.security_group_settings.password_requirements.lowercase #=> Integer
resp.security_group.security_group_settings.password_requirements.min_length #=> Integer
resp.security_group.security_group_settings.password_requirements.numbers #=> Integer
resp.security_group.security_group_settings.password_requirements.symbols #=> Integer
resp.security_group.security_group_settings.password_requirements.uppercase #=> Integer
resp.security_group.security_group_settings.presence_enabled #=> Boolean
resp.security_group.security_group_settings.quick_responses #=> Array
resp.security_group.security_group_settings.quick_responses[0] #=> String
resp.security_group.security_group_settings.show_master_recovery_key #=> Boolean
resp.security_group.security_group_settings.shredder.can_process_manually #=> Boolean
resp.security_group.security_group_settings.shredder.intensity #=> Integer
resp.security_group.security_group_settings.sso_max_idle_minutes #=> Integer
resp.security_group.security_group_settings.max_non_sso_session_minutes #=> Integer
resp.security_group.security_group_settings.federation_mode #=> Integer
resp.security_group.security_group_settings.lockout_threshold #=> Integer
resp.security_group.security_group_settings.permitted_networks #=> Array
resp.security_group.security_group_settings.permitted_networks[0] #=> String
resp.security_group.security_group_settings.permitted_wickr_aws_networks #=> Array
resp.security_group.security_group_settings.permitted_wickr_aws_networks[0].region #=> String
resp.security_group.security_group_settings.permitted_wickr_aws_networks[0].network_id #=> String
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks #=> Array
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks[0].domain #=> String
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks[0].network_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where the security group will be created.

  • :name (required, String) —

    The name for the new security group.

  • :security_group_settings (required, Types::SecurityGroupSettingsRequest) —

    The configuration settings for the security group, including permissions, federation settings, and feature controls.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



1678
1679
1680
1681
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1678

def create_security_group(params = {}, options = {})
  req = build_request(:create_security_group, params)
  req.send_request(options)
end

#delete_bot(params = {}) ⇒ Types::DeleteBotResponse

Deletes a bot from a specified Wickr network. This operation permanently removes the bot account and its associated data from the network.

Examples:

Example: Delete bot successfully


resp = client.delete_bot({
  bot_id: "98765", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "success", 
}

Example: Delete bot - bot not found


resp = client.delete_bot({
  bot_id: "99999", 
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.delete_bot({
  network_id: "NetworkId", # required
  bot_id: "BotId", # required
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which the bot will be deleted.

  • :bot_id (required, String) —

    The unique identifier of the bot to be deleted.

Returns:

See Also:



1732
1733
1734
1735
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1732

def delete_bot(params = {}, options = {})
  req = build_request(:delete_bot, params)
  req.send_request(options)
end

#delete_data_retention_bot(params = {}) ⇒ Types::DeleteDataRetentionBotResponse

Deletes the data retention bot from a Wickr network. This operation permanently removes the bot and all its associated data from the database.

Examples:

Example: Delete data retention bot successfully


resp = client.delete_data_retention_bot({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "deleted data retention bot and all associated data from the database", 
}

Request syntax with placeholder values


resp = client.delete_data_retention_bot({
  network_id: "NetworkId", # required
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which the data retention bot will be deleted.

Returns:

See Also:



1775
1776
1777
1778
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1775

def delete_data_retention_bot(params = {}, options = {})
  req = build_request(:delete_data_retention_bot, params)
  req.send_request(options)
end

#delete_network(params = {}) ⇒ Types::DeleteNetworkResponse

Deletes a Wickr network and all its associated resources, including users, bots, security groups, and settings. This operation is permanent and cannot be undone.

Examples:

Example: Delete network successfully


resp = client.delete_network({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "Network deletion initiated successfully", 
}

Example: Delete network - not found


resp = client.delete_network({
  network_id: "99999999", 
})

Request syntax with placeholder values


resp = client.delete_network({
  network_id: "NetworkId", # required
  client_token: "ClientToken",
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network to delete.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency. If you retry a request with the same client token, the service will return the same response without attempting to delete the network again.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



1832
1833
1834
1835
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1832

def delete_network(params = {}, options = {})
  req = build_request(:delete_network, params)
  req.send_request(options)
end

#delete_security_group(params = {}) ⇒ Types::DeleteSecurityGroupResponse

Deletes a security group from a Wickr network. This operation cannot be performed on the default security group.

Examples:

Example: Delete security group successfully


resp = client.delete_security_group({
  group_id: "def67890", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  group_id: "def67890", 
  message: "success", 
  network_id: "12345678", 
}

Example: Delete security group - not found


resp = client.delete_security_group({
  group_id: "invalid99", 
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.delete_security_group({
  network_id: "NetworkId", # required
  group_id: "GenericString", # required
})

Response structure


resp.message #=> String
resp.network_id #=> String
resp.group_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which the security group will be deleted.

  • :group_id (required, String) —

    The unique identifier of the security group to delete.

Returns:

See Also:



1892
1893
1894
1895
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1892

def delete_security_group(params = {}, options = {})
  req = build_request(:delete_security_group, params)
  req.send_request(options)
end

#get_bot(params = {}) ⇒ Types::GetBotResponse

Retrieves detailed information about a specific bot in a Wickr network, including its status, group membership, and authentication details.

Examples:

Example: Get bot successfully


resp = client.get_bot({
  bot_id: "98765", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  bot_id: "98765", 
  display_name: "Support Bot", 
  group_id: "default_group", 
  has_challenge: true, 
  last_login: "1704067200", 
  pubkey: "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCQ2dLQ0FRRUF4", 
  status: 2, 
  suspended: false, 
  uname: "abc123def456", 
  username: "support_bot", 
}

Example: Get bot - bot not found


resp = client.get_bot({
  bot_id: "99999", 
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.get_bot({
  network_id: "NetworkId", # required
  bot_id: "BotId", # required
})

Response structure


resp.bot_id #=> String
resp.display_name #=> String
resp.username #=> String
resp.uname #=> String
resp.pubkey #=> String
resp.status #=> Integer
resp.group_id #=> String
resp.has_challenge #=> Boolean
resp.suspended #=> Boolean
resp. #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the bot.

  • :bot_id (required, String) —

    The unique identifier of the bot to retrieve.

Returns:

See Also:



1973
1974
1975
1976
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 1973

def get_bot(params = {}, options = {})
  req = build_request(:get_bot, params)
  req.send_request(options)
end

#get_bots_count(params = {}) ⇒ Types::GetBotsCountResponse

Retrieves the count of bots in a Wickr network, categorized by their status (pending, active, and total).

Examples:

Example: Get bots count successfully


resp = client.get_bots_count({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  active: 12, 
  pending: 2, 
  total: 15, 
}

Example: Get bots count with filters


resp = client.get_bots_count({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  active: 12, 
  pending: 0, 
  total: 12, 
}

Request syntax with placeholder values


resp = client.get_bots_count({
  network_id: "NetworkId", # required
})

Response structure


resp.pending #=> Integer
resp.active #=> Integer
resp.total #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which to retrieve bot counts.

Returns:

See Also:



2033
2034
2035
2036
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2033

def get_bots_count(params = {}, options = {})
  req = build_request(:get_bots_count, params)
  req.send_request(options)
end

#get_data_retention_bot(params = {}) ⇒ Types::GetDataRetentionBotResponse

Retrieves information about the data retention bot in a Wickr network, including its status and whether the data retention service is enabled.

Examples:

Example: Get data retention bot successfully


resp = client.get_data_retention_bot({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  bot_exists: true, 
  bot_name: "compliance_12345678_bot", 
  is_bot_active: true, 
  is_data_retention_bot_registered: true, 
  is_data_retention_service_enabled: true, 
  is_pubkey_msg_acked: false, 
}

Example: Get data retention bot - not provisioned


resp = client.get_data_retention_bot({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  bot_exists: false, 
  bot_name: "compliance_12345678_bot", 
  is_bot_active: false, 
  is_data_retention_bot_registered: false, 
  is_data_retention_service_enabled: false, 
  is_pubkey_msg_acked: false, 
}

Request syntax with placeholder values


resp = client.get_data_retention_bot({
  network_id: "NetworkId", # required
})

Response structure


resp.bot_name #=> String
resp.bot_exists #=> Boolean
resp.is_bot_active #=> Boolean
resp.is_data_retention_bot_registered #=> Boolean
resp.is_data_retention_service_enabled #=> Boolean
resp.is_pubkey_msg_acked #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the data retention bot.

Returns:

See Also:



2106
2107
2108
2109
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2106

def get_data_retention_bot(params = {}, options = {})
  req = build_request(:get_data_retention_bot, params)
  req.send_request(options)
end

#get_guest_user_history_count(params = {}) ⇒ Types::GetGuestUserHistoryCountResponse

Retrieves historical guest user count data for a Wickr network, showing the number of guest users per billing period over the past 90 days.

Examples:

Example: Get guest user history count


resp = client.get_guest_user_history_count({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  history: [
    {
      count: "32", 
      month: "2024_01", 
    }, 
    {
      count: "28", 
      month: "2023_12", 
    }, 
    {
      count: "35", 
      month: "2023_11", 
    }, 
    {
      count: "22", 
      month: "2023_10", 
    }, 
    {
      count: "18", 
      month: "2023_09", 
    }, 
    {
      count: "15", 
      month: "2023_08", 
    }, 
  ], 
}

Example: Empty response for network with no guest user history


resp = client.get_guest_user_history_count({
  network_id: "87654321", 
})

resp.to_h outputs the following:
{
  history: [
  ], 
}

Request syntax with placeholder values


resp = client.get_guest_user_history_count({
  network_id: "NetworkId", # required
})

Response structure


resp.history #=> Array
resp.history[0].month #=> String
resp.history[0].count #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which to retrieve guest user history.

Returns:

See Also:



2187
2188
2189
2190
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2187

def get_guest_user_history_count(params = {}, options = {})
  req = build_request(:get_guest_user_history_count, params)
  req.send_request(options)
end

#get_network(params = {}) ⇒ Types::GetNetworkResponse

Retrieves detailed information about a specific Wickr network, including its configuration, access level, and status.

Examples:

Example: Get network successfully


resp = client.get_network({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  access_level: "PREMIUM", 
  aws_account_id: "123456789012", 
  migration_state: 0, 
  network_arn: "arn:aws:wickr:us-east-1:123456789012:network/12345678", 
  network_id: "12345678", 
  network_name: "Production Network", 
  standing: 1, 
}

Example: Get network - not found


resp = client.get_network({
  network_id: "99999999", 
})

Request syntax with placeholder values


resp = client.get_network({
  network_id: "NetworkId", # required
})

Response structure


resp.network_id #=> String
resp.network_name #=> String
resp.access_level #=> String, one of "STANDARD", "PREMIUM"
resp. #=> String
resp.network_arn #=> String
resp.standing #=> Integer
resp.free_trial_expiration #=> String
resp.migration_state #=> Integer
resp.encryption_key_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network to retrieve.

Returns:

See Also:



2256
2257
2258
2259
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2256

def get_network(params = {}, options = {})
  req = build_request(:get_network, params)
  req.send_request(options)
end

#get_network_settings(params = {}) ⇒ Types::GetNetworkSettingsResponse

Retrieves all network-level settings for a Wickr network, including client metrics, data retention, and other configuration options.

Examples:

Example: Get network settings with mixed value types


resp = client.get_network_settings({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  settings: [
    {
      type: "boolean", 
      value: "true", 
      option_name: "enableClientMetrics", 
    }, 
    {
      type: "boolean", 
      value: "true", 
      option_name: "dataRetention", 
    }, 
  ], 
}

Example: Get settings for network with defaults only


resp = client.get_network_settings({
  network_id: "87654321", 
})

resp.to_h outputs the following:
{
  settings: [
    {
      type: "boolean", 
      value: "false", 
      option_name: "enableClientMetrics", 
    }, 
    {
      type: "boolean", 
      value: "false", 
      option_name: "dataRetention", 
    }, 
  ], 
}

Example: Network not found error


resp = client.get_network_settings({
  network_id: "99999999", 
})

Request syntax with placeholder values


resp = client.get_network_settings({
  network_id: "NetworkId", # required
})

Response structure


resp.settings #=> Array
resp.settings[0].option_name #=> String
resp.settings[0].value #=> String
resp.settings[0].type #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network whose settings will be retrieved.

Returns:

See Also:



2339
2340
2341
2342
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2339

def get_network_settings(params = {}, options = {})
  req = build_request(:get_network_settings, params)
  req.send_request(options)
end

#get_oidc_info(params = {}) ⇒ Types::GetOidcInfoResponse

Retrieves the OpenID Connect (OIDC) configuration for a Wickr network, including SSO settings and optional token information if access token parameters are provided.

Examples:

Example: Get OIDC info successfully


resp = client.get_oidc_info({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  openid_connect_info: {
    client_id: "client123", 
    company_id: "us-east-1-company123", 
    issuer: "https://login.example.com", 
    redirect_url: "https://app.wickr.com/callback", 
    scopes: "openid profile email", 
    sso_token_buffer_minutes: 5, 
    user_id: "email", 
  }, 
}

Example: Get OIDC info - not configured


resp = client.get_oidc_info({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  openid_connect_info: {
    company_id: "", 
    issuer: "", 
    scopes: "", 
  }, 
}

Request syntax with placeholder values


resp = client.get_oidc_info({
  network_id: "NetworkId", # required
  client_id: "GenericString",
  code: "GenericString",
  grant_type: "GenericString",
  redirect_uri: "GenericString",
  url: "GenericString",
  client_secret: "SensitiveString",
  code_verifier: "GenericString",
  certificate: "GenericString",
})

Response structure


resp.openid_connect_info.application_name #=> String
resp.openid_connect_info.client_id #=> String
resp.openid_connect_info.company_id #=> String
resp.openid_connect_info.scopes #=> String
resp.openid_connect_info.issuer #=> String
resp.openid_connect_info.client_secret #=> String
resp.openid_connect_info.secret #=> String
resp.openid_connect_info.redirect_url #=> String
resp.openid_connect_info.user_id #=> String
resp.openid_connect_info.custom_username #=> String
resp.openid_connect_info.ca_certificate #=> String
resp.openid_connect_info.application_id #=> Integer
resp.openid_connect_info.sso_token_buffer_minutes #=> Integer
resp.openid_connect_info.extra_auth_params #=> String
resp.token_info.code_verifier #=> String
resp.token_info.code_challenge #=> String
resp.token_info.access_token #=> String
resp.token_info.id_token #=> String
resp.token_info.refresh_token #=> String
resp.token_info.token_type #=> String
resp.token_info.expires_in #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network whose OIDC configuration will be retrieved.

  • :client_id (String) —

    The OAuth client ID for retrieving access tokens (optional).

  • :code (String) —

    The authorization code for retrieving access tokens (optional).

  • :grant_type (String) —

    The OAuth grant type for retrieving access tokens (optional).

  • :redirect_uri (String) —

    The redirect URI for the OAuth flow (optional).

  • :url (String) —

    The URL for the OIDC provider (optional).

  • :client_secret (String) —

    The OAuth client secret for retrieving access tokens (optional).

  • :code_verifier (String) —

    The PKCE code verifier for enhanced security in the OAuth flow (optional).

  • :certificate (String) —

    The CA certificate for secure communication with the OIDC provider (optional).

Returns:

See Also:



2460
2461
2462
2463
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2460

def get_oidc_info(params = {}, options = {})
  req = build_request(:get_oidc_info, params)
  req.send_request(options)
end

#get_opentdf_config(params = {}) ⇒ Types::GetOpentdfConfigResponse

Retrieves the OpenTDF integration configuration for a Wickr network.

Examples:

Example: Get OpenTDF info successfully


resp = client.get_opentdf_config({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  provider: "virtru", 
}

Example: Get OpenTDF info - not configured


resp = client.get_opentdf_config({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  client_id: "", 
  client_secret: "", 
  domain: "", 
  provider: "", 
}

Request syntax with placeholder values


resp = client.get_opentdf_config({
  network_id: "NetworkId", # required
})

Response structure


resp.client_id #=> String
resp.domain #=> String
resp.client_secret #=> String
resp.provider #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which OpenTDF integration will be retrieved.

Returns:

See Also:



2524
2525
2526
2527
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2524

def get_opentdf_config(params = {}, options = {})
  req = build_request(:get_opentdf_config, params)
  req.send_request(options)
end

#get_security_group(params = {}) ⇒ Types::GetSecurityGroupResponse

Retrieves detailed information about a specific security group in a Wickr network, including its settings, member counts, and configuration.

Examples:

Example: Get security group successfully


resp = client.get_security_group({
  group_id: "abc12345", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  security_group: {
    name: "default", 
    active_members: 50, 
    bot_members: 5, 
    id: "abc12345", 
    is_default: true, 
    modified: 1638360000, 
    security_group_settings: {
      federation_mode: 1, 
      lockout_threshold: 10, 
    }, 
  }, 
}

Example: Get security group - not found


resp = client.get_security_group({
  group_id: "invalid99", 
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.get_security_group({
  network_id: "NetworkId", # required
  group_id: "GenericString", # required
})

Response structure


resp.security_group.active_members #=> Integer
resp.security_group.bot_members #=> Integer
resp.security_group.active_directory_guid #=> String
resp.security_group.id #=> String
resp.security_group.is_default #=> Boolean
resp.security_group.name #=> String
resp.security_group.modified #=> Integer
resp.security_group.security_group_settings.always_reauthenticate #=> Boolean
resp.security_group.security_group_settings.atak_package_values #=> Array
resp.security_group.security_group_settings.atak_package_values[0] #=> String
resp.security_group.security_group_settings.calling.can_start_11_call #=> Boolean
resp.security_group.security_group_settings.calling.can_video_call #=> Boolean
resp.security_group.security_group_settings.calling.force_tcp_call #=> Boolean
resp.security_group.security_group_settings.check_for_updates #=> Boolean
resp.security_group.security_group_settings.enable_atak #=> Boolean
resp.security_group.security_group_settings.enable_crash_reports #=> Boolean
resp.security_group.security_group_settings.enable_file_download #=> Boolean
resp.security_group.security_group_settings.enable_guest_federation #=> Boolean
resp.security_group.security_group_settings.enable_notification_preview #=> Boolean
resp.security_group.security_group_settings.enable_open_access_option #=> Boolean
resp.security_group.security_group_settings.enable_restricted_global_federation #=> Boolean
resp.security_group.security_group_settings.files_enabled #=> Boolean
resp.security_group.security_group_settings.force_device_lockout #=> Integer
resp.security_group.security_group_settings.force_open_access #=> Boolean
resp.security_group.security_group_settings.force_read_receipts #=> Boolean
resp.security_group.security_group_settings.global_federation #=> Boolean
resp.security_group.security_group_settings.is_ato_enabled #=> Boolean
resp.security_group.security_group_settings.is_link_preview_enabled #=> Boolean
resp.security_group.security_group_settings.location_allow_maps #=> Boolean
resp.security_group.security_group_settings.location_enabled #=> Boolean
resp.security_group.security_group_settings.max_auto_download_size #=> Integer
resp.security_group.security_group_settings.max_bor #=> Integer
resp.security_group.security_group_settings.max_ttl #=> Integer
resp.security_group.security_group_settings.message_forwarding_enabled #=> Boolean
resp.security_group.security_group_settings.password_requirements.lowercase #=> Integer
resp.security_group.security_group_settings.password_requirements.min_length #=> Integer
resp.security_group.security_group_settings.password_requirements.numbers #=> Integer
resp.security_group.security_group_settings.password_requirements.symbols #=> Integer
resp.security_group.security_group_settings.password_requirements.uppercase #=> Integer
resp.security_group.security_group_settings.presence_enabled #=> Boolean
resp.security_group.security_group_settings.quick_responses #=> Array
resp.security_group.security_group_settings.quick_responses[0] #=> String
resp.security_group.security_group_settings.show_master_recovery_key #=> Boolean
resp.security_group.security_group_settings.shredder.can_process_manually #=> Boolean
resp.security_group.security_group_settings.shredder.intensity #=> Integer
resp.security_group.security_group_settings.sso_max_idle_minutes #=> Integer
resp.security_group.security_group_settings.max_non_sso_session_minutes #=> Integer
resp.security_group.security_group_settings.federation_mode #=> Integer
resp.security_group.security_group_settings.lockout_threshold #=> Integer
resp.security_group.security_group_settings.permitted_networks #=> Array
resp.security_group.security_group_settings.permitted_networks[0] #=> String
resp.security_group.security_group_settings.permitted_wickr_aws_networks #=> Array
resp.security_group.security_group_settings.permitted_wickr_aws_networks[0].region #=> String
resp.security_group.security_group_settings.permitted_wickr_aws_networks[0].network_id #=> String
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks #=> Array
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks[0].domain #=> String
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks[0].network_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the security group.

  • :group_id (required, String) —

    The unique identifier of the security group to retrieve.

Returns:

See Also:



2645
2646
2647
2648
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2645

def get_security_group(params = {}, options = {})
  req = build_request(:get_security_group, params)
  req.send_request(options)
end

#get_user(params = {}) ⇒ Types::GetUserResponse

Retrieves detailed information about a specific user in a Wickr network, including their profile, status, and activity history.

Examples:

Example: Get user information


resp = client.get_user({
  network_id: "12345678", 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  first_name: "John", 
  is_admin: false, 
  last_activity: 1705500000, 
  last_login: 1705499000, 
  last_name: "Doe", 
  security_group_ids: [
    "BCTY8Qhe", 
  ], 
  status: 2, 
  suspended: false, 
  user_id: "12345", 
  username: "john.doe@example.com", 
}

Example: Get user info with activity time range


resp = client.get_user({
  end_time: Time.parse(1705500000), 
  network_id: "12345678", 
  start_time: Time.parse(1704067200), 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  first_name: "Jane", 
  is_admin: true, 
  last_activity: 1705400000, 
  last_login: 1705350000, 
  last_name: "Admin", 
  security_group_ids: [
    "BCTY8Qhe", 
    "ADMIN001", 
  ], 
  status: 2, 
  suspended: false, 
  user_id: "12345", 
  username: "jane.admin@example.com", 
}

Example: User not found error


resp = client.get_user({
  network_id: "12345678", 
  user_id: "99999", 
})

Example: Invalid userId error


resp = client.get_user({
  network_id: "12345678", 
  user_id: "99999", 
})

Request syntax with placeholder values


resp = client.get_user({
  network_id: "NetworkId", # required
  user_id: "UserId", # required
  start_time: Time.now,
  end_time: Time.now,
})

Response structure


resp.user_id #=> String
resp.first_name #=> String
resp.last_name #=> String
resp.username #=> String
resp.is_admin #=> Boolean
resp.suspended #=> Boolean
resp.status #=> Integer
resp.last_activity #=> Integer
resp. #=> Integer
resp.security_group_ids #=> Array
resp.security_group_ids[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the user.

  • :user_id (required, String) —

    The unique identifier of the user to retrieve.

  • :start_time (Time, DateTime, Date, Integer, String) —

    The start time for filtering the user's last activity. Only activity after this timestamp will be considered. Time is specified in epoch seconds.

  • :end_time (Time, DateTime, Date, Integer, String) —

    The end time for filtering the user's last activity. Only activity before this timestamp will be considered. Time is specified in epoch seconds.

Returns:

See Also:



2773
2774
2775
2776
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2773

def get_user(params = {}, options = {})
  req = build_request(:get_user, params)
  req.send_request(options)
end

#get_users_count(params = {}) ⇒ Types::GetUsersCountResponse

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.

Examples:

Example: Get user counts for network


resp = client.get_users_count({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  active: 25, 
  pending: 5, 
  rejected: 2, 
  remaining: 15, 
  total: 32, 
}

Example: Network with no users


resp = client.get_users_count({
  network_id: "87654321", 
})

resp.to_h outputs the following:
{
  active: 0, 
  pending: 0, 
  rejected: 0, 
  remaining: 50, 
  total: 0, 
}

Request syntax with placeholder values


resp = client.get_users_count({
  network_id: "NetworkId", # required
})

Response structure


resp.pending #=> Integer
resp.active #=> Integer
resp.rejected #=> Integer
resp.remaining #=> Integer
resp.total #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which to retrieve user counts.

Returns:

See Also:



2842
2843
2844
2845
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2842

def get_users_count(params = {}, options = {})
  req = build_request(:get_users_count, params)
  req.send_request(options)
end

#list_blocked_guest_users(params = {}) ⇒ Types::ListBlockedGuestUsersResponse

Retrieves a paginated list of guest users who have been blocked from a Wickr network. You can filter and sort the results.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: Get paginated list of blocked guest users


resp = client.list_blocked_guest_users({
  max_results: 10, 
  network_id: "12345678", 
  sort_direction: "DESC", 
  sort_fields: "modified", 
})

resp.to_h outputs the following:
{
  blocklist: [
    {
      admin: "admin@company.com", 
      modified: "2024-01-15 10:30:00", 
      username: "blocked.user1@example.com", 
      username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
    }, 
    {
      admin: "admin@company.com", 
      modified: "2024-01-10 14:20:00", 
      username: "blocked.user2@example.com", 
      username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
    }, 
    {
      admin: "security@company.com", 
      modified: "2024-01-05 09:15:00", 
      username: "blocked.user3@example.com", 
      username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
    }, 
  ], 
  next_token: "v1:pagination:f47ac10b-58cc-4372-a567-0e02b2c3d479", 
}

Example: Filter by username


resp = client.list_blocked_guest_users({
  network_id: "12345678", 
  username: "john.doe@example.com", 
})

resp.to_h outputs the following:
{
  blocklist: [
    {
      admin: "admin@company.com", 
      modified: "2023-12-20 16:45:00", 
      username: "john.doe@example.com", 
      username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
    }, 
  ], 
}

Example: Empty blocklist


resp = client.list_blocked_guest_users({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  blocklist: [
  ], 
}

Request syntax with placeholder values


resp = client.list_blocked_guest_users({
  network_id: "NetworkId", # required
  max_results: 1,
  sort_direction: "ASC", # accepts ASC, DESC
  sort_fields: "GenericString",
  username: "GenericString",
  admin: "GenericString",
  next_token: "GenericString",
})

Response structure


resp.next_token #=> String
resp.blocklist #=> Array
resp.blocklist[0].username #=> String
resp.blocklist[0].admin #=> String
resp.blocklist[0].modified #=> String
resp.blocklist[0].username_hash #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which to list blocked guest users.

  • :max_results (Integer) —

    The maximum number of blocked guest users to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

  • :sort_fields (String) —

    The field to sort blocked guest users by. Accepted values include 'username', 'admin', and 'modified'.

  • :username (String) —

    Filter results to only include blocked guest users with usernames matching this value.

  • :admin (String) —

    Filter results to only include blocked guest users that were blocked by this administrator.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

Returns:

See Also:



2975
2976
2977
2978
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 2975

def list_blocked_guest_users(params = {}, options = {})
  req = build_request(:list_blocked_guest_users, params)
  req.send_request(options)
end

#list_bots(params = {}) ⇒ Types::ListBotsResponse

Retrieves a paginated list of bots in a specified Wickr network. You can filter and sort the results based on various criteria.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: List bots with pagination


resp = client.list_bots({
  max_results: 10, 
  network_id: "12345678", 
  sort_direction: "ASC", 
  sort_fields: "username", 
})

resp.to_h outputs the following:
{
  bots: [
    {
      bot_id: "98765", 
      display_name: "Analytics Bot", 
      group_id: "analytics_group", 
      has_challenge: true, 
      last_login: "1704067200", 
      pubkey: "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCQ2dLQ0FRRUF4", 
      status: 2, 
      suspended: false, 
      uname: "abc123def456", 
      username: "analytics_bot", 
    }, 
    {
      bot_id: "98766", 
      display_name: "Support Bot", 
      group_id: "support_group", 
      has_challenge: true, 
      last_login: "1704153600", 
      pubkey: "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCQ2dLQ0FRRUF5", 
      status: 2, 
      suspended: false, 
      uname: "def456ghi789", 
      username: "support_bot", 
    }, 
  ], 
  next_token: "eyJzdGFydEluZGV4IjoxMH0=", 
}

Example: List bots with filters


resp = client.list_bots({
  display_name: "Support", 
  max_results: 10, 
  network_id: "12345678", 
  status: 2, 
})

resp.to_h outputs the following:
{
  bots: [
    {
      bot_id: "98766", 
      display_name: "Support Bot", 
      group_id: "support_group", 
      has_challenge: true, 
      last_login: "1704153600", 
      pubkey: "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCQ2dLQ0FRRUF5", 
      status: 2, 
      suspended: false, 
      uname: "def456ghi789", 
      username: "support_bot", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_bots({
  network_id: "NetworkId", # required
  next_token: "GenericString",
  max_results: 1,
  sort_fields: "GenericString",
  sort_direction: "ASC", # accepts ASC, DESC
  display_name: "GenericString",
  username: "GenericString",
  status: 1,
  group_id: "GenericString",
})

Response structure


resp.bots #=> Array
resp.bots[0].bot_id #=> String
resp.bots[0].display_name #=> String
resp.bots[0].username #=> String
resp.bots[0].uname #=> String
resp.bots[0].pubkey #=> String
resp.bots[0].status #=> Integer
resp.bots[0].group_id #=> String
resp.bots[0].has_challenge #=> Boolean
resp.bots[0].suspended #=> Boolean
resp.bots[0]. #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which to list bots.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

  • :max_results (Integer) —

    The maximum number of bots to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_fields (String) —

    The fields to sort bots by. Multiple fields can be specified by separating them with '+'. Accepted values include 'username', 'firstName', 'displayName', 'status', and 'groupId'.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

  • :display_name (String) —

    Filter results to only include bots with display names matching this value.

  • :username (String) —

    Filter results to only include bots with usernames matching this value.

  • :status (Integer) —

    Filter results to only include bots with this status (1 for pending, 2 for active).

  • :group_id (String) —

    Filter results to only include bots belonging to this security group.

Returns:

See Also:



3126
3127
3128
3129
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3126

def list_bots(params = {}, options = {})
  req = build_request(:list_bots, params)
  req.send_request(options)
end

#list_devices_for_user(params = {}) ⇒ Types::ListDevicesForUserResponse

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.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: Successful device list retrieval


resp = client.list_devices_for_user({
  max_results: 10, 
  network_id: "12345678", 
  sort_direction: "DESC", 
  sort_fields: "appId", 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  devices: [
    {
      type: "mobile", 
      app_id: "d3135a42dcb6437780b16c3ca9581fe64e6822773cd6b965d25fc9929c89aca6", 
      created: "January 15th 2024, 2:30:45 pm", 
      last_login: "January 20th 2024, 9:15:30 am", 
      status_text: "Active", 
      suspend: false, 
    }, 
    {
      type: "desktop", 
      app_id: "e4246b53edc7548891c27d4da0692fe75f7933884de7c076e36gca030d90bdb7", 
      created: "December 10th 2023, 11:45:20 am", 
      last_login: "January 18th 2024, 4:20:15 pm", 
      status_text: "Suspended", 
      suspend: true, 
    }, 
  ], 
}

Example: Retrieving subsequent page of devices


resp = client.list_devices_for_user({
  max_results: 10, 
  network_id: "12345678", 
  next_token: "v1:pagination:6ba7b810-9dad-11d1-80b4-00c04fd430c8", 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  devices: [
    {
      type: "web", 
      app_id: "f5357c64fde8659002c38e5db1804gf86g8044995ef8d187f47hdb141e01dce8", 
      created: "January 1st 2024, 12:00:00 pm", 
      last_login: "January 21st 2024, 8:22:00 am", 
      status_text: "Active", 
      suspend: false, 
    }, 
    {
      type: "mobile", 
      app_id: "g6468d75gef9760113d49f6ec2915hg97h9155aa6fg9e298g58iec252f12edf9", 
      created: "December 24th 2023, 4:00:00 pm", 
      last_login: "January 20th 2024, 9:15:30 am", 
      status_text: "Active", 
      suspend: false, 
    }, 
  ], 
  next_token: "v1:pagination:7cb8c921-aebe-22e2-91c5-11d05fe541d9", 
}

Example: Invalid userId error


resp = client.list_devices_for_user({
  max_results: 10, 
  network_id: "12345678", 
  user_id: "99999", 
})

Request syntax with placeholder values


resp = client.list_devices_for_user({
  network_id: "NetworkId", # required
  user_id: "UserId", # required
  next_token: "GenericString",
  max_results: 1,
  sort_fields: "GenericString",
  sort_direction: "ASC", # accepts ASC, DESC
})

Response structure


resp.next_token #=> String
resp.devices #=> Array
resp.devices[0].app_id #=> String
resp.devices[0].created #=> String
resp.devices[0]. #=> String
resp.devices[0].status_text #=> String
resp.devices[0].suspend #=> Boolean
resp.devices[0].type #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the user.

  • :user_id (required, String) —

    The unique identifier of the user whose devices will be listed.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

  • :max_results (Integer) —

    The maximum number of devices to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_fields (String) —

    The fields to sort devices by. Multiple fields can be specified by separating them with '+'. Accepted values include 'lastlogin', 'type', 'suspend', and 'created'.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

Returns:

See Also:



3264
3265
3266
3267
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3264

def list_devices_for_user(params = {}, options = {})
  req = build_request(:list_devices_for_user, params)
  req.send_request(options)
end

#list_guest_users(params = {}) ⇒ Types::ListGuestUsersResponse

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.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: Get paginated list of guest users


resp = client.list_guest_users({
  max_results: 20, 
  network_id: "12345678", 
  sort_direction: "DESC", 
  sort_fields: "billingPeriod", 
})

resp.to_h outputs the following:
{
  guestlist: [
    {
      billing_period: "2024-01", 
      username: "guest1@example.com", 
      username_hash: "e8e55b924aee6554edb87816c66704564504d25fbb95fc4dbc944feb977cbc26", 
    }, 
    {
      billing_period: "2024-01", 
      username: "guest2@example.com", 
      username_hash: "a9e55b924aee6554edb87816c66704564504d25fbb95fc4dbc944feb977cbc26", 
    }, 
    {
      billing_period: "2023-12", 
      username: "guest3@example.com", 
      username_hash: "c3e55b924aee6554edb87816c66704564504d25fbb95fc4dbc944feb977cbc26", 
    }, 
    {
      billing_period: "2023-12", 
      username: "guest4@example.com", 
      username_hash: "k2e55b924aee6554edb87816c66704564504d25fbb95fc4dbc944feb977cbc26", 
    }, 
  ], 
  next_token: "v1:pagination:550e8400-e29b-41d4-a716-446655440000", 
}

Example: Filter by billing period


resp = client.list_guest_users({
  billing_period: "2024-01", 
  max_results: 10, 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  guestlist: [
    {
      billing_period: "2024-01", 
      username: "guest1@example.com", 
      username_hash: "e8e55b924aee6554edb87816c66704564504d25fbb95fc4dbc944feb977cbc26", 
    }, 
    {
      billing_period: "2024-01", 
      username: "guest2@example.com", 
      username_hash: "a9e55b924aee6554edb87816c66704564504d25fbb95fc4dbc944feb977cbc26", 
    }, 
  ], 
  next_token: "v1:pagination:6ba7b810-9dad-11d1-80b4-00c04fd430c8", 
}

Example: Empty guest list


resp = client.list_guest_users({
  network_id: "87654321", 
})

resp.to_h outputs the following:
{
  guestlist: [
  ], 
}

Request syntax with placeholder values


resp = client.list_guest_users({
  network_id: "NetworkId", # required
  max_results: 1,
  sort_direction: "ASC", # accepts ASC, DESC
  sort_fields: "GenericString",
  username: "GenericString",
  billing_period: "GenericString",
  next_token: "GenericString",
})

Response structure


resp.next_token #=> String
resp.guestlist #=> Array
resp.guestlist[0].billing_period #=> String
resp.guestlist[0].username #=> String
resp.guestlist[0].username_hash #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which to list guest users.

  • :max_results (Integer) —

    The maximum number of guest users to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

  • :sort_fields (String) —

    The field to sort guest users by. Accepted values include 'username' and 'billingPeriod'.

  • :username (String) —

    Filter results to only include guest users with usernames matching this value.

  • :billing_period (String) —

    Filter results to only include guest users from this billing period (e.g., '2024-01').

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

Returns:

See Also:



3405
3406
3407
3408
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3405

def list_guest_users(params = {}, options = {})
  req = build_request(:list_guest_users, params)
  req.send_request(options)
end

#list_networks(params = {}) ⇒ Types::ListNetworksResponse

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.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: List networks with pagination


resp = client.list_networks({
  max_results: 10, 
  sort_direction: "ASC", 
  sort_fields: "networkName", 
})

resp.to_h outputs the following:
{
  networks: [
    {
      access_level: "STANDARD", 
      aws_account_id: "123456789012", 
      network_arn: "arn:aws:wickr:us-east-1:123456789012:network/12345678", 
      network_id: "12345678", 
      network_name: "Dev Network", 
      standing: 1, 
    }, 
    {
      access_level: "PREMIUM", 
      aws_account_id: "123456789012", 
      network_arn: "arn:aws:wickr:us-east-1:123456789012:network/87654321", 
      network_id: "87654321", 
      network_name: "Prod Network", 
      standing: 1, 
    }, 
  ], 
  next_token: "eyJvZmZzZXQiOjEwfQ==", 
}

Example: List networks - first page


resp = client.list_networks({
  max_results: 10, 
})

resp.to_h outputs the following:
{
  networks: [
    {
      access_level: "PREMIUM", 
      aws_account_id: "123456789012", 
      network_arn: "arn:aws:wickr:us-east-1:123456789012:network/12345678", 
      network_id: "12345678", 
      network_name: "Production Network", 
      standing: 1, 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_networks({
  max_results: 1,
  sort_fields: "GenericString",
  sort_direction: "ASC", # accepts ASC, DESC
  next_token: "GenericString",
})

Response structure


resp.networks #=> Array
resp.networks[0].network_id #=> String
resp.networks[0].network_name #=> String
resp.networks[0].access_level #=> String, one of "STANDARD", "PREMIUM"
resp.networks[0]. #=> String
resp.networks[0].network_arn #=> String
resp.networks[0].standing #=> Integer
resp.networks[0].free_trial_expiration #=> String
resp.networks[0].migration_state #=> Integer
resp.networks[0].encryption_key_arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of networks to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_fields (String) —

    The field to sort networks by. Accepted values are 'networkId' and 'networkName'. Default is 'networkId'.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

Returns:

See Also:



3516
3517
3518
3519
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3516

def list_networks(params = {}, options = {})
  req = build_request(:list_networks, params)
  req.send_request(options)
end

#list_security_group_users(params = {}) ⇒ Types::ListSecurityGroupUsersResponse

Retrieves a paginated list of users who belong to a specific security group in a Wickr network.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: List security group users with pagination


resp = client.list_security_group_users({
  group_id: "abc12345", 
  max_results: 10, 
  network_id: "12345678", 
  sort_direction: "ASC", 
  sort_fields: "username", 
})

resp.to_h outputs the following:
{
  next_token: "eyJvZmZzZXQiOjEwfQ==", 
  users: [
    {
      first_name: "Alice", 
      last_name: "Smith", 
      username: "alice@example.com", 
    }, 
    {
      first_name: "Bob", 
      last_name: "Jones", 
      username: "bob@example.com", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_security_group_users({
  network_id: "NetworkId", # required
  group_id: "GenericString", # required
  next_token: "GenericString",
  max_results: 1,
  sort_fields: "GenericString",
  sort_direction: "ASC", # accepts ASC, DESC
})

Response structure


resp.users #=> Array
resp.users[0].user_id #=> String
resp.users[0].first_name #=> String
resp.users[0].last_name #=> String
resp.users[0].username #=> String
resp.users[0].security_groups #=> Array
resp.users[0].security_groups[0] #=> String
resp.users[0].is_admin #=> Boolean
resp.users[0].suspended #=> Boolean
resp.users[0].status #=> Integer
resp.users[0].otp_enabled #=> Boolean
resp.users[0].scim_id #=> String
resp.users[0].type #=> String
resp.users[0].cell #=> String
resp.users[0].country_code #=> String
resp.users[0].challenge_failures #=> Integer
resp.users[0].is_invite_expired #=> Boolean
resp.users[0].is_user #=> Boolean
resp.users[0].invite_code #=> String
resp.users[0].code_validation #=> Boolean
resp.users[0].uname #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the security group.

  • :group_id (required, String) —

    The unique identifier of the security group whose users will be listed.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

  • :max_results (Integer) —

    The maximum number of users to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_fields (String) —

    The field to sort users by. Multiple fields can be specified by separating them with '+'. Accepted values include 'username', 'firstName', and 'lastName'.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

Returns:

See Also:



3623
3624
3625
3626
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3623

def list_security_group_users(params = {}, options = {})
  req = build_request(:list_security_group_users, params)
  req.send_request(options)
end

#list_security_groups(params = {}) ⇒ Types::ListSecurityGroupsResponse

Retrieves a paginated list of security groups in a specified Wickr network. You can sort the results by various criteria.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: List security groups with pagination


resp = client.list_security_groups({
  max_results: 10, 
  network_id: "12345678", 
  sort_direction: "ASC", 
  sort_fields: "name", 
})

resp.to_h outputs the following:
{
  next_token: "eyJvZmZzZXQiOjEwfQ==", 
  security_groups: [
    {
      name: "default", 
      active_members: 25, 
      bot_members: 0, 
      id: "abc12345", 
      is_default: true, 
      modified: 1638360000, 
      security_group_settings: {
        lockout_threshold: 10, 
      }, 
    }, 
    {
      name: "engineering", 
      active_members: 10, 
      bot_members: 2, 
      id: "def67890", 
      is_default: false, 
      modified: 1638360000, 
      security_group_settings: {
        lockout_threshold: 15, 
      }, 
    }, 
  ], 
}

Example: List security groups - first page


resp = client.list_security_groups({
  max_results: 10, 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  security_groups: [
    {
      name: "default", 
      active_members: 25, 
      bot_members: 0, 
      id: "abc12345", 
      is_default: true, 
      modified: 1638360000, 
      security_group_settings: {
        lockout_threshold: 10, 
      }, 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_security_groups({
  network_id: "NetworkId", # required
  next_token: "GenericString",
  max_results: 1,
  sort_fields: "GenericString",
  sort_direction: "ASC", # accepts ASC, DESC
})

Response structure


resp.security_groups #=> Array
resp.security_groups[0].active_members #=> Integer
resp.security_groups[0].bot_members #=> Integer
resp.security_groups[0].active_directory_guid #=> String
resp.security_groups[0].id #=> String
resp.security_groups[0].is_default #=> Boolean
resp.security_groups[0].name #=> String
resp.security_groups[0].modified #=> Integer
resp.security_groups[0].security_group_settings.always_reauthenticate #=> Boolean
resp.security_groups[0].security_group_settings.atak_package_values #=> Array
resp.security_groups[0].security_group_settings.atak_package_values[0] #=> String
resp.security_groups[0].security_group_settings.calling.can_start_11_call #=> Boolean
resp.security_groups[0].security_group_settings.calling.can_video_call #=> Boolean
resp.security_groups[0].security_group_settings.calling.force_tcp_call #=> Boolean
resp.security_groups[0].security_group_settings.check_for_updates #=> Boolean
resp.security_groups[0].security_group_settings.enable_atak #=> Boolean
resp.security_groups[0].security_group_settings.enable_crash_reports #=> Boolean
resp.security_groups[0].security_group_settings.enable_file_download #=> Boolean
resp.security_groups[0].security_group_settings.enable_guest_federation #=> Boolean
resp.security_groups[0].security_group_settings.enable_notification_preview #=> Boolean
resp.security_groups[0].security_group_settings.enable_open_access_option #=> Boolean
resp.security_groups[0].security_group_settings.enable_restricted_global_federation #=> Boolean
resp.security_groups[0].security_group_settings.files_enabled #=> Boolean
resp.security_groups[0].security_group_settings.force_device_lockout #=> Integer
resp.security_groups[0].security_group_settings.force_open_access #=> Boolean
resp.security_groups[0].security_group_settings.force_read_receipts #=> Boolean
resp.security_groups[0].security_group_settings.global_federation #=> Boolean
resp.security_groups[0].security_group_settings.is_ato_enabled #=> Boolean
resp.security_groups[0].security_group_settings.is_link_preview_enabled #=> Boolean
resp.security_groups[0].security_group_settings.location_allow_maps #=> Boolean
resp.security_groups[0].security_group_settings.location_enabled #=> Boolean
resp.security_groups[0].security_group_settings.max_auto_download_size #=> Integer
resp.security_groups[0].security_group_settings.max_bor #=> Integer
resp.security_groups[0].security_group_settings.max_ttl #=> Integer
resp.security_groups[0].security_group_settings.message_forwarding_enabled #=> Boolean
resp.security_groups[0].security_group_settings.password_requirements.lowercase #=> Integer
resp.security_groups[0].security_group_settings.password_requirements.min_length #=> Integer
resp.security_groups[0].security_group_settings.password_requirements.numbers #=> Integer
resp.security_groups[0].security_group_settings.password_requirements.symbols #=> Integer
resp.security_groups[0].security_group_settings.password_requirements.uppercase #=> Integer
resp.security_groups[0].security_group_settings.presence_enabled #=> Boolean
resp.security_groups[0].security_group_settings.quick_responses #=> Array
resp.security_groups[0].security_group_settings.quick_responses[0] #=> String
resp.security_groups[0].security_group_settings.show_master_recovery_key #=> Boolean
resp.security_groups[0].security_group_settings.shredder.can_process_manually #=> Boolean
resp.security_groups[0].security_group_settings.shredder.intensity #=> Integer
resp.security_groups[0].security_group_settings.sso_max_idle_minutes #=> Integer
resp.security_groups[0].security_group_settings.max_non_sso_session_minutes #=> Integer
resp.security_groups[0].security_group_settings.federation_mode #=> Integer
resp.security_groups[0].security_group_settings.lockout_threshold #=> Integer
resp.security_groups[0].security_group_settings.permitted_networks #=> Array
resp.security_groups[0].security_group_settings.permitted_networks[0] #=> String
resp.security_groups[0].security_group_settings.permitted_wickr_aws_networks #=> Array
resp.security_groups[0].security_group_settings.permitted_wickr_aws_networks[0].region #=> String
resp.security_groups[0].security_group_settings.permitted_wickr_aws_networks[0].network_id #=> String
resp.security_groups[0].security_group_settings.permitted_wickr_enterprise_networks #=> Array
resp.security_groups[0].security_group_settings.permitted_wickr_enterprise_networks[0].domain #=> String
resp.security_groups[0].security_group_settings.permitted_wickr_enterprise_networks[0].network_id #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which to list security groups.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

  • :max_results (Integer) —

    The maximum number of security groups to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_fields (String) —

    The field to sort security groups by. Accepted values include 'id' and 'name'.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

Returns:

See Also:



3796
3797
3798
3799
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3796

def list_security_groups(params = {}, options = {})
  req = build_request(:list_security_groups, params)
  req.send_request(options)
end

#list_users(params = {}) ⇒ Types::ListUsersResponse

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.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: Get paginated list of users


resp = client.list_users({
  max_results: 20, 
  network_id: "12345678", 
  sort_direction: "ASC", 
  sort_fields: "username", 
})

resp.to_h outputs the following:
{
  next_token: "v1:pagination:6ba7b810-9dad-11d1-80b4-00c04fd430c8", 
  users: [
    {
      type: "user", 
      first_name: "Alice", 
      is_admin: false, 
      last_name: "Anderson", 
      status: 2, 
      suspended: false, 
      username: "alice.anderson@example.com", 
    }, 
    {
      type: "user", 
      first_name: "Bob", 
      is_admin: false, 
      last_name: "Brown", 
      status: 2, 
      suspended: false, 
      username: "bob.brown@example.com", 
    }, 
    {
      type: "user", 
      first_name: "Charlie", 
      is_admin: true, 
      last_name: "Chen", 
      status: 2, 
      suspended: false, 
      username: "charlie.chen@example.com", 
    }, 
  ], 
}

Example: Filter by status and group


resp = client.list_users({
  group_id: "BCTY8Qhe", 
  max_results: 10, 
  network_id: "12345678", 
  status: 1, 
})

resp.to_h outputs the following:
{
  users: [
    {
      type: "user", 
      first_name: "David", 
      invite_code: "INVITE789", 
      is_admin: false, 
      is_invite_expired: false, 
      last_name: "Davis", 
      status: 1, 
      suspended: false, 
      username: "david.davis@example.com", 
    }, 
  ], 
}

Example: Empty user list for network with no users


resp = client.list_users({
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  users: [
  ], 
}

Request syntax with placeholder values


resp = client.list_users({
  network_id: "NetworkId", # required
  next_token: "GenericString",
  max_results: 1,
  sort_fields: "GenericString",
  sort_direction: "ASC", # accepts ASC, DESC
  first_name: "SensitiveString",
  last_name: "SensitiveString",
  username: "GenericString",
  status: 1,
  group_id: "GenericString",
})

Response structure


resp.next_token #=> String
resp.users #=> Array
resp.users[0].user_id #=> String
resp.users[0].first_name #=> String
resp.users[0].last_name #=> String
resp.users[0].username #=> String
resp.users[0].security_groups #=> Array
resp.users[0].security_groups[0] #=> String
resp.users[0].is_admin #=> Boolean
resp.users[0].suspended #=> Boolean
resp.users[0].status #=> Integer
resp.users[0].otp_enabled #=> Boolean
resp.users[0].scim_id #=> String
resp.users[0].type #=> String
resp.users[0].cell #=> String
resp.users[0].country_code #=> String
resp.users[0].challenge_failures #=> Integer
resp.users[0].is_invite_expired #=> Boolean
resp.users[0].is_user #=> Boolean
resp.users[0].invite_code #=> String
resp.users[0].code_validation #=> Boolean
resp.users[0].uname #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network from which to list users.

  • :next_token (String) —

    The token for retrieving the next page of results. This is returned from a previous request when there are more results available.

  • :max_results (Integer) —

    The maximum number of users to return in a single page. Valid range is 1-100. Default is 10.

  • :sort_fields (String) —

    The fields to sort users by. Multiple fields can be specified by separating them with '+'. Accepted values include 'username', 'firstName', 'lastName', 'status', and 'groupId'.

  • :sort_direction (String) —

    The direction to sort results. Valid values are 'ASC' (ascending) or 'DESC' (descending). Default is 'DESC'.

  • :first_name (String) —

    Filter results to only include users with first names matching this value.

  • :last_name (String) —

    Filter results to only include users with last names matching this value.

  • :username (String) —

    Filter results to only include users with usernames matching this value.

  • :status (Integer) —

    Filter results to only include users with this status (1 for pending, 2 for active).

  • :group_id (String) —

    Filter results to only include users belonging to this security group.

Returns:

See Also:



3977
3978
3979
3980
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 3977

def list_users(params = {}, options = {})
  req = build_request(:list_users, params)
  req.send_request(options)
end

#register_oidc_config(params = {}) ⇒ Types::RegisterOidcConfigResponse

Registers and saves an OpenID Connect (OIDC) configuration for a Wickr network, enabling Single Sign-On (SSO) authentication through an identity provider.

Examples:

Example: Save OIDC config successfully


resp = client.register_oidc_config({
  company_id: "us-east-1-company123", 
  issuer: "https://login.example.com", 
  network_id: "12345678", 
  scopes: "openid profile email", 
  sso_token_buffer_minutes: 5, 
  user_id: "email", 
})

resp.to_h outputs the following:
{
  client_id: "client123", 
  company_id: "us-east-1-company123", 
  issuer: "https://login.example.com", 
  redirect_url: "https://app.wickr.com/callback", 
  scopes: "openid profile email", 
  sso_token_buffer_minutes: 5, 
  user_id: "email", 
}

Example: Save OIDC config - missing company ID


resp = client.register_oidc_config({
  company_id: "", 
  issuer: "https://login.example.com", 
  network_id: "12345678", 
  scopes: "openid profile email", 
})

Example: Save OIDC config - invalid company ID prefix


resp = client.register_oidc_config({
  company_id: "invalid-company123", 
  issuer: "https://login.example.com", 
  network_id: "12345678", 
  scopes: "openid profile email", 
})

Request syntax with placeholder values


resp = client.register_oidc_config({
  network_id: "NetworkId", # required
  company_id: "GenericString", # required
  custom_username: "GenericString",
  extra_auth_params: "GenericString",
  issuer: "GenericString", # required
  scopes: "GenericString", # required
  secret: "SensitiveString",
  sso_token_buffer_minutes: 1,
  user_id: "GenericString",
})

Response structure


resp.application_name #=> String
resp.client_id #=> String
resp.company_id #=> String
resp.scopes #=> String
resp.issuer #=> String
resp.client_secret #=> String
resp.secret #=> String
resp.redirect_url #=> String
resp.user_id #=> String
resp.custom_username #=> String
resp.ca_certificate #=> String
resp.application_id #=> Integer
resp.sso_token_buffer_minutes #=> Integer
resp.extra_auth_params #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which OIDC will be configured.

  • :company_id (required, String) —

    Custom identifier your end users will use to sign in with SSO.

  • :custom_username (String) —

    A custom field mapping to extract the username from the OIDC token (optional).

    The customUsername is only required if you use something other than email as the username field.

  • :extra_auth_params (String) —

    Additional authentication parameters to include in the OIDC flow (optional).

  • :issuer (required, String) —

    The issuer URL of the OIDC provider (e.g., 'https://login.example.com').

  • :scopes (required, String) —

    The OAuth scopes to request from the OIDC provider (e.g., 'openid profile email').

  • :secret (String) —

    The client secret for authenticating with the OIDC provider (optional).

  • :sso_token_buffer_minutes (Integer) —

    The buffer time in minutes before the SSO token expires to refresh it (optional).

  • :user_id (String) —

    Unique identifier provided by your identity provider to authenticate the access request. Also referred to as clientID.

Returns:

See Also:



4118
4119
4120
4121
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4118

def register_oidc_config(params = {}, options = {})
  req = build_request(:register_oidc_config, params)
  req.send_request(options)
end

#register_oidc_config_test(params = {}) ⇒ Types::RegisterOidcConfigTestResponse

Tests an OpenID Connect (OIDC) configuration for a Wickr network by validating the connection to the identity provider and retrieving its supported capabilities.

Examples:

Example: Test OIDC config successfully


resp = client.register_oidc_config_test({
  issuer: "https://login.example.com", 
  network_id: "12345678", 
  scopes: "openid profile email", 
})

resp.to_h outputs the following:
{
  authorization_endpoint: "https://login.example.com/authorize", 
  issuer: "https://login.example.com", 
  token_endpoint: "https://login.example.com/oauth/token", 
  userinfo_endpoint: "https://login.example.com/userinfo", 
}

Example: Test OIDC config - missing issuer


resp = client.register_oidc_config_test({
  issuer: "", 
  network_id: "12345678", 
  scopes: "openid profile email", 
})

Example: Test OIDC config - invalid endpoint


resp = client.register_oidc_config_test({
  issuer: "https://blocked-endpoint.com", 
  network_id: "12345678", 
  scopes: "openid profile email", 
})

Request syntax with placeholder values


resp = client.register_oidc_config_test({
  network_id: "NetworkId", # required
  extra_auth_params: "GenericString",
  issuer: "GenericString", # required
  scopes: "GenericString", # required
  certificate: "GenericString",
})

Response structure


resp.token_endpoint #=> String
resp.userinfo_endpoint #=> String
resp.response_types_supported #=> Array
resp.response_types_supported[0] #=> String
resp.scopes_supported #=> Array
resp.scopes_supported[0] #=> String
resp.issuer #=> String
resp.authorization_endpoint #=> String
resp.end_session_endpoint #=> String
resp.logout_endpoint #=> String
resp.grant_types_supported #=> Array
resp.grant_types_supported[0] #=> String
resp.revocation_endpoint #=> String
resp.token_endpoint_auth_methods_supported #=> Array
resp.token_endpoint_auth_methods_supported[0] #=> String
resp.microsoft_multi_refresh_token #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which the OIDC configuration will be tested.

  • :extra_auth_params (String) —

    Additional authentication parameters to include in the test (optional).

  • :issuer (required, String) —

    The issuer URL of the OIDC provider to test.

  • :scopes (required, String) —

    The OAuth scopes to test with the OIDC provider.

  • :certificate (String) —

    The CA certificate for secure communication with the OIDC provider (optional).

Returns:

See Also:



4226
4227
4228
4229
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4226

def register_oidc_config_test(params = {}, options = {})
  req = build_request(:register_oidc_config_test, params)
  req.send_request(options)
end

#register_opentdf_config(params = {}) ⇒ Types::RegisterOpentdfConfigResponse

Registers and saves OpenTDF configuration for a Wickr network, enabling attribute-based access control for Wickr through an OpenTDF provider.

Examples:

Example: Save OpenTDF config successfully


resp = client.register_opentdf_config({
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  network_id: "12345678", 
  provider: "virtru", 
})

resp.to_h outputs the following:
{
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  provider: "virtru", 
}

Example: Dry run saving OpenTDF config


resp = client.register_opentdf_config({
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  dry_run: true, 
  network_id: "12345678", 
  provider: "virtru", 
})

resp.to_h outputs the following:
{
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  provider: "virtru", 
}

Example: Dry run saving OpenTDF config - failed test


resp = client.register_opentdf_config({
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  dry_run: true, 
  network_id: "12345678", 
  provider: "virtru", 
})

Example: Save OpenTDF config - invalid provider


resp = client.register_opentdf_config({
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  network_id: "12345678", 
  provider: "invalid provider", 
})

Example: Save OpenTDF config - network not found


resp = client.register_opentdf_config({
  client_id: "client123", 
  client_secret: "secret456", 
  domain: "https://api.sample.com", 
  network_id: "99999999", 
  provider: "virtru", 
})

Request syntax with placeholder values


resp = client.register_opentdf_config({
  network_id: "NetworkId", # required
  client_id: "GenericString", # required
  client_secret: "SensitiveString", # required
  domain: "GenericString", # required
  provider: "GenericString", # required
  dry_run: false,
})

Response structure


resp.client_id #=> String
resp.domain #=> String
resp.client_secret #=> String
resp.provider #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network for which OpenTDF integration will be configured.

  • :client_id (required, String) —

    The OIDC client ID used for authenticating with the OpenTDF provider.

  • :client_secret (required, String) —

    The OIDC client secret used for authenticating with the OpenTDF provider

  • :domain (required, String) —

    The domain of the OpenTDF server.

  • :provider (required, String) —

    The provider of the OpenTDF platform.

    Currently only Virtru is supported as the OpenTDF provider.

  • :dry_run (Boolean) —

    Perform dry-run test connection of OpenTDF configuration (optional).

Returns:

See Also:



4357
4358
4359
4360
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4357

def register_opentdf_config(params = {}, options = {})
  req = build_request(:register_opentdf_config, params)
  req.send_request(options)
end

#update_bot(params = {}) ⇒ Types::UpdateBotResponse

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.

Examples:

Example: Update bot successfully


resp = client.update_bot({
  bot_id: "98765", 
  display_name: "Updated Support Bot", 
  group_id: "support_group", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "success", 
}

Example: Update bot - bot not found


resp = client.update_bot({
  bot_id: "99999", 
  display_name: "Updated Bot", 
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.update_bot({
  network_id: "NetworkId", # required
  bot_id: "BotId", # required
  display_name: "GenericString",
  group_id: "GenericString",
  challenge: "SensitiveString",
  suspend: false,
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the bot to update.

  • :bot_id (required, String) —

    The unique identifier of the bot to update.

  • :display_name (String) —

    The new display name for the bot.

  • :group_id (String) —

    The ID of the new security group to assign the bot to.

  • :challenge (String) —

    The new password for the bot account.

  • :suspend (Boolean) —

    Set to true to suspend the bot or false to unsuspend it. Omit this field for standard updates that don't affect suspension status.

Returns:

See Also:



4431
4432
4433
4434
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4431

def update_bot(params = {}, options = {})
  req = build_request(:update_bot, params)
  req.send_request(options)
end

#update_data_retention(params = {}) ⇒ Types::UpdateDataRetentionResponse

Updates the data retention bot settings, allowing you to enable or disable the data retention service, or acknowledge the public key message.

Examples:

Example: Update data retention - enable service


resp = client.update_data_retention({
  action_type: "ENABLE", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "data retention service enabled", 
}

Example: Update data retention - disable service


resp = client.update_data_retention({
  action_type: "DISABLE", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "data retention service disabled", 
}

Example: Update data retention - acknowledge pubkey message


resp = client.update_data_retention({
  action_type: "PUBKEY_MSG_ACK", 
  network_id: "12345678", 
})

resp.to_h outputs the following:
{
  message: "pubkey message was acknowledged", 
}

Request syntax with placeholder values


resp = client.update_data_retention({
  network_id: "NetworkId", # required
  action_type: "ENABLE", # required, accepts ENABLE, DISABLE, PUBKEY_MSG_ACK
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the data retention bot.

  • :action_type (required, String) —

    The action to perform. Valid values are 'ENABLE' (to enable the data retention service), 'DISABLE' (to disable the service), or 'PUBKEY_MSG_ACK' (to acknowledge the public key message).

Returns:

See Also:



4504
4505
4506
4507
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4504

def update_data_retention(params = {}, options = {})
  req = build_request(:update_data_retention, params)
  req.send_request(options)
end

#update_guest_user(params = {}) ⇒ Types::UpdateGuestUserResponse

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.

Examples:

Example: Block a guest user


resp = client.update_guest_user({
  block: true, 
  network_id: "12345678", 
  username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
})

resp.to_h outputs the following:
{
  message: "success", 
}

Example: Unblock a guest user


resp = client.update_guest_user({
  block: false, 
  network_id: "12345678", 
  username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
})

resp.to_h outputs the following:
{
  message: "success", 
}

Example: User already blocked error


resp = client.update_guest_user({
  block: true, 
  network_id: "12345678", 
  username_hash: "032c36d5623781204592a69269ed9480d604484269c8a4c2d39528885a56470d", 
})

Request syntax with placeholder values


resp = client.update_guest_user({
  network_id: "NetworkId", # required
  username_hash: "GenericString", # required
  block: false, # required
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network where the guest user's status will be updated.

  • :username_hash (required, String) —

    The username hash (unique identifier) of the guest user to update.

  • :block (required, Boolean) —

    Set to true to block the guest user or false to unblock them.

Returns:

See Also:



4578
4579
4580
4581
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4578

def update_guest_user(params = {}, options = {})
  req = build_request(:update_guest_user, params)
  req.send_request(options)
end

#update_network(params = {}) ⇒ Types::UpdateNetworkResponse

Updates the properties of an existing Wickr network, such as its name or encryption key configuration.

Examples:

Example: Update network name successfully


resp = client.update_network({
  network_id: "12345678", 
  network_name: "Updated Network Name", 
})

resp.to_h outputs the following:
{
  message: "Network updated successfully", 
}

Example: Update network - invalid name


resp = client.update_network({
  network_id: "12345678", 
  network_name: "This name is way too long for a network", 
})

Example: Update network - not found


resp = client.update_network({
  network_id: "99999999", 
  network_name: "New Name", 
})

Request syntax with placeholder values


resp = client.update_network({
  network_id: "NetworkId", # required
  network_name: "GenericString", # required
  client_token: "ClientToken",
  encryption_key_arn: "GenericString",
})

Response structure


resp.message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network to update.

  • :network_name (required, String) —

    The new name for the network. Must be between 1 and 20 characters.

  • :client_token (String) —

    A unique identifier for this request to ensure idempotency.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

  • :encryption_key_arn (String) —

    The ARN of the Amazon Web Services KMS customer managed key to use for encrypting sensitive data in the network.

Returns:

See Also:



4650
4651
4652
4653
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4650

def update_network(params = {}, options = {})
  req = build_request(:update_network, params)
  req.send_request(options)
end

#update_network_settings(params = {}) ⇒ Types::UpdateNetworkSettingsResponse

Updates network-level settings for a Wickr network. You can modify settings such as client metrics, data retention, and other network-wide options.

Examples:

Example: Update multiple network settings


resp = client.update_network_settings({
  network_id: "12345678", 
  settings: {
    data_retention: true, 
    enable_client_metrics: true, 
  }, 
})

resp.to_h outputs the following:
{
  settings: [
    {
      type: "boolean", 
      value: "true", 
      option_name: "enableClientMetrics", 
    }, 
    {
      type: "boolean", 
      value: "true", 
      option_name: "dataRetention", 
    }, 
  ], 
}

Example: Update single boolean setting


resp = client.update_network_settings({
  network_id: "12345678", 
  settings: {
    enable_client_metrics: false, 
  }, 
})

resp.to_h outputs the following:
{
  settings: [
    {
      type: "boolean", 
      value: "false", 
      option_name: "enableClientMetrics", 
    }, 
  ], 
}

Example: Update client metrics settings


resp = client.update_network_settings({
  network_id: "12345678", 
  settings: {
    enable_client_metrics: true, 
  }, 
})

resp.to_h outputs the following:
{
  settings: [
    {
      type: "boolean", 
      value: "true", 
      option_name: "enableClientMetrics", 
    }, 
  ], 
}

Example: Invalid setting name error


resp = client.update_network_settings({
  network_id: "12345678", 
  settings: {
    enable_client_metrics: false, 
  }, 
})

Example: Network not found error


resp = client.update_network_settings({
  network_id: "99999999", 
  settings: {
    enable_client_metrics: true, 
  }, 
})

Example: Invalid value type error


resp = client.update_network_settings({
  network_id: "12345678", 
  settings: {
    data_retention: true, 
  }, 
})

Request syntax with placeholder values


resp = client.update_network_settings({
  network_id: "NetworkId", # required
  settings: { # required
    enable_client_metrics: false,
    read_receipt_config: {
      status: "DISABLED", # accepts DISABLED, ENABLED, FORCE_ENABLED
    },
    data_retention: false,
    enable_trusted_data_format: false,
    consent_popup: {
      enabled: false, # required
      header: "ConsentPopupConfigHeaderString",
      content: "ConsentPopupConfigContentString",
      close_button_label: "ConsentPopupConfigCloseButtonLabelString",
    },
  },
})

Response structure


resp.settings #=> Array
resp.settings[0].option_name #=> String
resp.settings[0].value #=> String
resp.settings[0].type #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network whose settings will be updated.

  • :settings (required, Types::NetworkSettings) —

    A map of setting names to their new values. Each setting should be provided with its appropriate type (boolean, string, number, etc.).

Returns:

See Also:



4795
4796
4797
4798
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4795

def update_network_settings(params = {}, options = {})
  req = build_request(:update_network_settings, params)
  req.send_request(options)
end

#update_security_group(params = {}) ⇒ Types::UpdateSecurityGroupResponse

Updates the properties of an existing security group in a Wickr network, such as its name or settings.

Examples:

Example: Update security group successfully


resp = client.update_security_group({
  name: "Updated Group Name", 
  group_id: "abc12345", 
  network_id: "12345678", 
  security_group_settings: {
    lockout_threshold: 15, 
  }, 
})

resp.to_h outputs the following:
{
  security_group: {
    name: "Updated Group Name", 
    active_members: 10, 
    bot_members: 2, 
    id: "abc12345", 
    is_default: false, 
    modified: 1638360000, 
    security_group_settings: {
      lockout_threshold: 15, 
    }, 
  }, 
}

Example: Update security group - not found


resp = client.update_security_group({
  name: "New Name", 
  group_id: "invalid99", 
  network_id: "12345678", 
})

Request syntax with placeholder values


resp = client.update_security_group({
  network_id: "NetworkId", # required
  group_id: "GenericString", # required
  name: "GenericString",
  security_group_settings: {
    always_reauthenticate: false,
    atak_package_values: ["GenericString"],
    calling: {
      can_start_11_call: false,
      can_video_call: false,
      force_tcp_call: false,
    },
    check_for_updates: false,
    enable_atak: false,
    enable_crash_reports: false,
    enable_file_download: false,
    enable_guest_federation: false,
    enable_notification_preview: false,
    enable_open_access_option: false,
    enable_restricted_global_federation: false,
    files_enabled: false,
    force_device_lockout: 1,
    force_open_access: false,
    force_read_receipts: false,
    global_federation: false,
    is_ato_enabled: false,
    is_link_preview_enabled: false,
    location_allow_maps: false,
    location_enabled: false,
    max_auto_download_size: 1,
    max_bor: 1,
    max_ttl: 1,
    message_forwarding_enabled: false,
    password_requirements: {
      lowercase: 1,
      min_length: 1,
      numbers: 1,
      symbols: 1,
      uppercase: 1,
    },
    presence_enabled: false,
    quick_responses: ["GenericString"],
    show_master_recovery_key: false,
    shredder: {
      can_process_manually: false,
      intensity: 1,
    },
    sso_max_idle_minutes: 1,
    max_non_sso_session_minutes: 1,
    federation_mode: 1,
    lockout_threshold: 1,
    permitted_networks: ["NetworkId"],
    permitted_wickr_aws_networks: [
      {
        region: "GenericString", # required
        network_id: "NetworkId", # required
      },
    ],
    permitted_wickr_enterprise_networks: [
      {
        domain: "GenericString", # required
        network_id: "NetworkId", # required
      },
    ],
  },
})

Response structure


resp.security_group.active_members #=> Integer
resp.security_group.bot_members #=> Integer
resp.security_group.active_directory_guid #=> String
resp.security_group.id #=> String
resp.security_group.is_default #=> Boolean
resp.security_group.name #=> String
resp.security_group.modified #=> Integer
resp.security_group.security_group_settings.always_reauthenticate #=> Boolean
resp.security_group.security_group_settings.atak_package_values #=> Array
resp.security_group.security_group_settings.atak_package_values[0] #=> String
resp.security_group.security_group_settings.calling.can_start_11_call #=> Boolean
resp.security_group.security_group_settings.calling.can_video_call #=> Boolean
resp.security_group.security_group_settings.calling.force_tcp_call #=> Boolean
resp.security_group.security_group_settings.check_for_updates #=> Boolean
resp.security_group.security_group_settings.enable_atak #=> Boolean
resp.security_group.security_group_settings.enable_crash_reports #=> Boolean
resp.security_group.security_group_settings.enable_file_download #=> Boolean
resp.security_group.security_group_settings.enable_guest_federation #=> Boolean
resp.security_group.security_group_settings.enable_notification_preview #=> Boolean
resp.security_group.security_group_settings.enable_open_access_option #=> Boolean
resp.security_group.security_group_settings.enable_restricted_global_federation #=> Boolean
resp.security_group.security_group_settings.files_enabled #=> Boolean
resp.security_group.security_group_settings.force_device_lockout #=> Integer
resp.security_group.security_group_settings.force_open_access #=> Boolean
resp.security_group.security_group_settings.force_read_receipts #=> Boolean
resp.security_group.security_group_settings.global_federation #=> Boolean
resp.security_group.security_group_settings.is_ato_enabled #=> Boolean
resp.security_group.security_group_settings.is_link_preview_enabled #=> Boolean
resp.security_group.security_group_settings.location_allow_maps #=> Boolean
resp.security_group.security_group_settings.location_enabled #=> Boolean
resp.security_group.security_group_settings.max_auto_download_size #=> Integer
resp.security_group.security_group_settings.max_bor #=> Integer
resp.security_group.security_group_settings.max_ttl #=> Integer
resp.security_group.security_group_settings.message_forwarding_enabled #=> Boolean
resp.security_group.security_group_settings.password_requirements.lowercase #=> Integer
resp.security_group.security_group_settings.password_requirements.min_length #=> Integer
resp.security_group.security_group_settings.password_requirements.numbers #=> Integer
resp.security_group.security_group_settings.password_requirements.symbols #=> Integer
resp.security_group.security_group_settings.password_requirements.uppercase #=> Integer
resp.security_group.security_group_settings.presence_enabled #=> Boolean
resp.security_group.security_group_settings.quick_responses #=> Array
resp.security_group.security_group_settings.quick_responses[0] #=> String
resp.security_group.security_group_settings.show_master_recovery_key #=> Boolean
resp.security_group.security_group_settings.shredder.can_process_manually #=> Boolean
resp.security_group.security_group_settings.shredder.intensity #=> Integer
resp.security_group.security_group_settings.sso_max_idle_minutes #=> Integer
resp.security_group.security_group_settings.max_non_sso_session_minutes #=> Integer
resp.security_group.security_group_settings.federation_mode #=> Integer
resp.security_group.security_group_settings.lockout_threshold #=> Integer
resp.security_group.security_group_settings.permitted_networks #=> Array
resp.security_group.security_group_settings.permitted_networks[0] #=> String
resp.security_group.security_group_settings.permitted_wickr_aws_networks #=> Array
resp.security_group.security_group_settings.permitted_wickr_aws_networks[0].region #=> String
resp.security_group.security_group_settings.permitted_wickr_aws_networks[0].network_id #=> String
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks #=> Array
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks[0].domain #=> String
resp.security_group.security_group_settings.permitted_wickr_enterprise_networks[0].network_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the security group to update.

  • :group_id (required, String) —

    The unique identifier of the security group to update.

  • :name (String) —

    The new name for the security group.

  • :security_group_settings (Types::SecurityGroupSettings) —

    The updated configuration settings for the security group.

    Federation mode - 0 (Local federation), 1 (Restricted federation), 2 (Global federation)

Returns:

See Also:



4990
4991
4992
4993
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 4990

def update_security_group(params = {}, options = {})
  req = build_request(:update_security_group, params)
  req.send_request(options)
end

#update_user(params = {}) ⇒ Types::UpdateUserResponse

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.

Examples:

Example: Update user information


resp = client.update_user({
  network_id: "12345678", 
  user_details: {
    first_name: "Jonathan", 
    last_name: "Doe", 
    security_group_ids: [
      "BCTY8Qhe", 
      "DEPT001", 
    ], 
    username: "john.doe@example.com", 
  }, 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  first_name: "Jonathan", 
  last_name: "Doe", 
  modified: 1705500000, 
  network_id: "12345678", 
  security_group_ids: [
    "BCTY8Qhe", 
    "DEPT001", 
  ], 
  status: 2, 
  suspended: false, 
  user_id: "12345", 
}

Example: Update user with invite code


resp = client.update_user({
  network_id: "12345678", 
  user_details: {
    code_validation: true, 
    first_name: "Jane", 
    invite_code: "NEWINVITE789", 
    invite_code_ttl: 14, 
    last_name: "Smith", 
    username: "jane.smith@example.com", 
  }, 
  user_id: "12345", 
})

resp.to_h outputs the following:
{
  code_validation: true, 
  first_name: "Jane", 
  invite_code: "NEWINVITE789", 
  invite_expiration: 1706709600, 
  last_name: "Smith", 
  modified: 1705500100, 
  network_id: "12345678", 
  status: 2, 
  suspended: false, 
  user_id: "12345", 
}

Example: User not found error


resp = client.update_user({
  network_id: "12345678", 
  user_details: {
    first_name: "Non", 
    last_name: "Existent", 
    username: "nonexistent@example.com", 
  }, 
  user_id: "99999", 
})

Example: Invalid userId error


resp = client.update_user({
  network_id: "12345678", 
  user_details: {
    first_name: "John", 
    last_name: "Doe", 
    security_group_ids: [
      "BCTY8Qhe", 
    ], 
    username: "john.doe@example.com", 
  }, 
  user_id: "99999", 
})

Request syntax with placeholder values


resp = client.update_user({
  network_id: "NetworkId", # required
  user_id: "UserId", # required
  user_details: {
    first_name: "SensitiveString",
    last_name: "SensitiveString",
    username: "GenericString",
    security_group_ids: ["SecurityGroupId"],
    invite_code: "GenericString",
    invite_code_ttl: 1,
    code_validation: false,
  },
})

Response structure


resp.user_id #=> String
resp.network_id #=> String
resp.security_group_ids #=> Array
resp.security_group_ids[0] #=> String
resp.first_name #=> String
resp.last_name #=> String
resp.middle_name #=> String
resp.suspended #=> Boolean
resp.modified #=> Integer
resp.status #=> Integer
resp.invite_code #=> String
resp.invite_expiration #=> Integer
resp.code_validation #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :network_id (required, String) —

    The ID of the Wickr network containing the user to update.

  • :user_id (required, String) —

    The unique identifier of the user to update.

  • :user_details (Types::UpdateUserDetails) —

    An object containing the user details to be updated, such as name, password, security groups, and invite code settings.

Returns:

See Also:



5153
5154
5155
5156
 
# File 'gems/aws-sdk-wickr/lib/aws-sdk-wickr/client.rb', line 5153

def update_user(params = {}, options = {})
  req = build_request(:update_user, params)
  req.send_request(options)
end