view release on metacpan or  search on metacpan

CompanyNames/TextSupport.pm  view on Meta::CPAN

crease creased creases creasing
create created creater creates creating creation creationism creations creative creatively creativeness creatives creativity creator creators
creationist creationists
creature creatures
creche creches
credential credentialed credentialing credentials
credentialled credentialling
credenza credenzas
credibility credible credibly
credit creditability creditable creditably credited crediting credits
creditor creditors

 view release on metacpan or  search on metacpan

lib/Finance/FXCM/Simple.pm  view on Meta::CPAN

Your FXCM account password

=item C<$type>

The account type the login credentials apply to. Either 'Demo' or 'Real'.


=item C<$url>

The url to connect to, typically this will be 'http://www.fxcorporate.com/Hosts.jsp'

 view release on metacpan or  search on metacpan

lib/Finance/GDAX/API.pm  view on Meta::CPAN

passphrase:andTHisiSMypassPhraSE

There can be comments ("#" beginning a line), and blank lines.

In other words, for exmple, if you cryptographically store your API
credentials, you can create a small callable program that will decrypt
them and provide them, so that they never live on disk unencrypted,
and never show up in process listings:

  my $request = Finance::GDAX::API->new;
  $request->external_secret('/path/to/my_decryptor', 1);

 view release on metacpan or  search on metacpan

Testing/test-record.pl  view on Meta::CPAN

# This file needs a valid account to do anything useful. 
# This will be your account, not mine! 
# You can hardcode here or use a credential fiie. 
# Running this script will allow you to generate 
# new canned test data for new test scripts. 
if ( eval (require "credentials.pl") ) 
{
  $ig=Finance::IG->new(cred()); 
} 
else
{ 

 view release on metacpan or  search on metacpan

lib/Finance/MtGox.pm  view on Meta::CPAN

=head1 BASIC METHODS

=head2 new

Create a new C<Finance::MtGox> object with your MtGox credentials provided
in the C<key> and C<secret> arguments.

=cut

sub new {
    my ( $class, $args ) = @_;

    $args->{key} && $args->{secret}
      or croak "You must provide 'key' and 'secret' credentials.";

    $args->{json} = JSON::Any->new;
    $args->{mech} = WWW::Mechanize->new(stack_depth => 0);

    return bless $args, $class;

 view release on metacpan or  search on metacpan

lib/Finance/PaycheckRecords/Fetcher.pm  view on Meta::CPAN

    mech     => WWW::Mechanize->new,
  }, $class;
} # end new

#---------------------------------------------------------------------
# Get a URL, automatically supplying login credentials if needed:

sub _get
{
  my ($self, $url) = @_;

 view release on metacpan or  search on metacpan

YahooQuote.pm  view on Meta::CPAN

    my $self = LWP::UserAgent::new(@_);
    $self->agent("Finance-YahooQuote/0.18");
    $self;
  }

  sub get_basic_credentials {
    my $self = @_;
    if (defined($PROXYUSER) and defined($PROXYPASSWD) and
 	$PROXYUSER ne "" and $PROXYPASSWD ne "") {
      return ($PROXYUSER, $PROXYPASSWD);
    } else {

 view release on metacpan or  search on metacpan

lib/Firefox/Marionette.pm  view on Meta::CPAN

        $authenticator = $self->webauthn_authenticator();
    }
    return $authenticator;
}

sub webauthn_credentials {
    my ( $self, $parameter_authenticator ) = @_;
    my $authenticator = $self->_get_webauthn_authenticator(
        authenticator => $parameter_authenticator );
    my $message_id = $self->_new_message_id();
    $self->_send_request(

lib/Firefox/Marionette.pm  view on Meta::CPAN

          MIME::Base64::decode_base64url( $credential->{userHandle} );
    }
    return $credential;
}

sub delete_webauthn_all_credentials {
    my ( $self, $parameter_authenticator ) = @_;
    my $authenticator = $self->_get_webauthn_authenticator(
        authenticator => $parameter_authenticator );
    my $message_id = $self->_new_message_id();
    $self->_send_request(

lib/Firefox/Marionette.pm  view on Meta::CPAN

accepts a hash of the following keys;

=over 4

=item * has_resident_key - boolean value to indicate if the authenticator will support L<client side discoverable credentials|https://www.w3.org/TR/webauthn-2/#client-side-discoverable-credential>

=item * has_user_verification - boolean value to determine if the L<authenticator|https://www.w3.org/TR/webauthn-2/#virtual-authenticators> supports L<user verification|https://www.w3.org/TR/webauthn-2/#user-verification>.

=item * is_user_consenting - boolean value to determine the result of all L<user consent|https://www.w3.org/TR/webauthn-2/#user-consent> L<authorization gestures|https://www.w3.org/TR/webauthn-2/#authorization-gesture>, and by extension, any L<test o...

lib/Firefox/Marionette.pm  view on Meta::CPAN

    $firefox->find_id('input-email')->type($user_name);
    $firefox->find_id('register-button')->click();
    $firefox->await(sub { sleep 1; $firefox->find_class('alert-success'); });
    $firefox->find_id('login-button')->click();
    $firefox->await(sub { sleep 1; $firefox->find_class('hero confetti'); });
    foreach my $credential ($firefox->webauthn_credentials()) {
        $firefox->delete_webauthn_credential($credential);

# ... time passes ...

        $firefox->add_webauthn_credential(

lib/Firefox/Marionette.pm  view on Meta::CPAN

will remove the L<User-Agent|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent>, L<Accept|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept> and L<Accept-Encoding|https://developer.mozilla.org/en-US/docs/Web/HTTP/Hea...

This method returns L<itself|Firefox::Marionette> to aid in chaining methods.

=head2 delete_webauthn_all_credentials

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will delete all L<credentials|Firefox::Marionette::WebAuthn::Credential> from this authenticator.  If no parameter is supplied, the defaul...

    my $firefox = Firefox::Marionette->new();
    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    $firefox->delete_webauthn_all_credentials($authenticator);
    $firefox->delete_webauthn_all_credentials();

=head2 delete_webauthn_authenticator

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will delete this authenticator from the current Firefox instance.  If no parameter is supplied, the default authenticator will be deleted.

lib/Firefox/Marionette.pm  view on Meta::CPAN

    use Firefox::Marionette();

    my $firefox = Firefox::Marionette->new();
    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    foreach my $credential ($firefox->webauthn_credentials($authenticator)) {
        $firefox->delete_webauthn_credential($credential, $authenticator);
    }

just a L<credential|Firefox::Marionette::WebAuthn::Credential>, in which case it will remove the credential from the default authenticator.

    use Firefox::Marionette();

    my $firefox = Firefox::Marionette->new();
    ...
    foreach my $credential ($firefox->webauthn_credentials()) {
        $firefox->delete_webauthn_credential($credential);
    }

This method returns L<itself|Firefox::Marionette> to aid in chaining methods.

lib/Firefox/Marionette.pm  view on Meta::CPAN

=head2 webauthn_authenticator

returns the default L<WebAuthn authenticator|Firefox::Marionette::WebAuthn::Authenticator> created when the L<new|/new> method was called.

=head2 webauthn_credentials

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will return all the L<credentials|Firefox::Marionette::WebAuthn::Credential> attached to this authenticator.  If no parameter is supplied,...

    use Firefox::Marionette();
    use v5.10;

    my $firefox = Firefox::Marionette->new();
    foreach my $credential ($firefox->webauthn_credentials()) {
       say "Credential host is " . $credential->host();
    }

    # OR

    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    foreach my $credential ($firefox->webauthn_credentials($authenticator)) {
       say "Credential host is " . $credential->host();
    }

=head2 webauthn_set_user_verified

 view release on metacpan or  search on metacpan

lib/Firefox/Sync/Client.pm  view on Meta::CPAN

    my ($self, $url) = @_;

    # Initialize LWP
    my $ua = LWP::UserAgent->new;
    $ua->agent ("FFsyncClient/0.1 ");
    $ua->credentials ( $self->{'hostname'} . ':' . $self->{'port'}, 'Sync', $self->{'username'} => $self->{'password'} );

    # Do the request
    my $res = $ua->get($url);
    die $res->{'_msg'} if ($res->{'_rc'} != '200');

 view release on metacpan or  search on metacpan

doc/examples/petmarket/petmarket/api/userservice.pm  view on Meta::CPAN

sub methodTable
{
    return {
        "addUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
        "getUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
        "updateUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
    };
    
}

 view release on metacpan or  search on metacpan

lib/Flickr/Upload/FireEagle.pm  view on Meta::CPAN

Aaron Straup Cope <ascope@cpan.org>

=head1 NOTES

Aside from requiring your own Flickr API key, secret and authentication token
you will also need similar FireEagle (OAuth) credentials. Since Flickr::Upload::FireEagle
already requires that you install the excellent I<Net::FireEagle> you should just
use the command line I<fireeagle> client for authorizing yourself with FireEagle.

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

flickr_upload  view on Meta::CPAN

    else {
        die "Unable to initiate OAuth authorization. Response from Flickr was: '$response'\n";
    }
    my $ac_rc = $ua->oauth_access_token(\%request_token);
    if($ac_rc eq 'ok') {
        print "Saving OAuth credentials to $oauth_config\n";
        $ua->export_storable_config($oauth_config);
    }
}

if(!exists $args{'auth_token'} && -r $oauth_config) {
    $ua = Flickr::Upload->import_storable_config($oauth_config);
    bless $ua, 'Flickr::Upload';
}

die "No auth token or OAuth credentials found.\nUse --auth or --oauth to generate credentials or --auth_token to specify a token.\n"
    unless exists $args{'auth_token'} || $ua->is_oauth;

if( $check ) {
	exit( checkToken( $ua, $args{api_key}, $args{auth_token} ) );
}

flickr_upload  view on Meta::CPAN

Authentication token. You B<must> get an authentication token using
C<--auth> before you can upload images. See the L<EXAMPLES> section.

=item --oauth

Interactively perform OAuth authorization with Flickr. The user will get a URL to visit at Flickr at which Flickr::Upload must be granted write permissions. After granting permission, the user will be redirected to a dummy URL that contains an OAuth ...

=item --title <title>

Title to use on all the images. Optional.

flickr_upload  view on Meta::CPAN

Note that options unknown to Flickr will result in undefined behaviour.

=item --check

Checks the authentication token via the flickr.auth.checkToken API call.
This can be used to verify API keys and credentials without trying to
upload an image. The output is the raw results of the API call.

=item --progress, --no-progress

Display a progress bar for each upload with L<Term::ProgressBar>. That

 view release on metacpan or  search on metacpan

lib/Footprintless/Plugin/Ldap/Ldap.pm  view on Meta::CPAN

    my ( $self, $dn, %options ) = @_;
    croak('not connected') unless ( $self->{connection} );

    if ( !$dn ) {

        # binding with instance credentials
        $dn      = $self->{bind_dn};
        %options = %{ $self->{bind_options} };
    }

    if ($dn) {

 view release on metacpan or  search on metacpan

t/Footprintless.t  view on Meta::CPAN

my ($fpl);

ok( $fpl = Footprintless->new(
        config_dirs            => File::Spec->catdir( $test_dir,  'config/entities' ),
        config_properties_file => File::Spec->catfile( $test_dir, 'config/credentials.pl' )
    ),
    'load data/entities'
);

ok( $fpl->entities()->{dev}, 'root is dev' );

 view release on metacpan or  search on metacpan

lib/ForgeOps/Tracker/Configuration.pm  view on Meta::CPAN

    my $parsed = $self->_parsed_dsn;
    return undef unless $parsed && defined $parsed->{api_key} && length $parsed->{api_key};
    return $parsed->{api_key};
}

# The ingestion URL with credentials stripped out (they travel as the Authorization header
# instead, never embedded in the request URI).
sub ingestion_uri {
    my ($self) = @_;
    my $parsed = $self->_parsed_dsn;
    return undef unless $parsed;

 view release on metacpan or  search on metacpan

TODO  view on Meta::CPAN

            t/24e-kill.t does not terminate

    _X_ have a "remote_host" option to go with "cmd" option
        _X_ remote_host => host
        _X_ remote_host => [host, user, pwd]
            to run on a remote server that requires some credentials
        _X_ remote_host => [ \@hosts ]  or  [ \@hosts, user, pwd ]
            to run on any of a cluster of available remote hosts
        _X_ allow a separate MAX_PROC-like setting to be used for
            remote hosts
        ___ remote_host_proto => 'ssh'

 view release on metacpan or  search on metacpan

lib/LWP/UserAgent/FramesReady.pm  view on Meta::CPAN

Get/set the B<$self->{'nomax'}> can be used by the included callback
routine to enforce truncation of received content even if the request
to do so is not honored by the server called for the content.

=item $ua->credent([$credentials])

Get/set the credentials for authentification if called for.

=item $ua->errors()

Get the last error encountered if a return was an undef.  This routine
has only been tested in development so there is no guarantee that it

lib/LWP/UserAgent/FramesReady.pm  view on Meta::CPAN

    }

    return 1;
}

=item $ua->get_basic_credentials()

This routine overloads the LWP::UserAgent::get_basic_credentials in
order to supply authorization if it has been pre-loaded an initial/new
or by use of the $ua->credent() routine.  Supplies a return in a list
context of a UserID and a Password to LWP::UserAgent::credentials().

=cut

sub get_basic_credentials {
    my($self, $realm, $uri) = @_;

    $self->{'errstring'} = '';
    if ($self->{credent}) {
        return split(':', $self->{credent}, 2);

 view release on metacpan or  search on metacpan

lib/FreeMED/Relay.pm  view on Meta::CPAN

	$JSON::QuotApos = 1;
	$JSON::BareKey = 1;
	return $self;
}

sub set_credentials {
	my $self = shift;

	my ( $base_uri, $username, $password ) = @_;
	print "base_uri = $base_uri\n" if $self->{'debug'};
	print "username = $username\n" if $self->{'debug'};

lib/FreeMED/Relay.pm  view on Meta::CPAN

}

sub login {
	my $self = shift;
	if (!defined($self->{username}) or !defined($self->{password})) {
		die "login(): Must set credentials before logging in\n";
	}

	$self->_init() if (!defined($self->{ua}));
	my $login = $self->call(
		'org.freemedsoftware.public.Login.Validate',

lib/FreeMED/Relay.pm  view on Meta::CPAN

Returns a FreeMED::Relay object.

C<new> takes "debug" as a boolean argument.

=item set_credentials ( $base_uri, $username, $password )

Sets the credentials used to access the FreeMED installation in question. The
C<$base_uri> variable should be the base name of the installation, such as
"http://localhost/freemed".

=item login ( )

 view release on metacpan or  search on metacpan

lib/Fugu/Control.pm  view on Meta::CPAN

# How long a client waits for one frame.
use constant DEFAULT_TIMEOUT => 5;

# The platform predicate of peer. Only OpenBSD reports the peer
# credentials in the struct sockpeercred order: the user id, then the
# group id, then the process id. The Linux struct ucred holds the
# process id first, and one module must not carry two field orders.
# The base perl of OpenBSD exports Socket::SO_PEERCRED (0x1022), so
# no compiled module is necessary.
use constant PEER_SUPPORTED => $^O eq 'openbsd';

lib/Fugu/Control.pm  view on Meta::CPAN

		# The read cannot fail on a healthy UNIX socket, so a
		# failure names a broken assumption. A control socket
		# that cannot name its peer must not answer.
		unless ($peer) {
			$self->_log->error(
				'Cannot read the peer credentials on %s: %s',
				$self->{path}, $fault );
			CORE::close $client;
			return;
		}
	}

lib/Fugu/Control.pm  view on Meta::CPAN

	unless ($handler) {
		return $self->_send_error( $imsg, $peerid,
			"unknown command: $command" );
	}

	# The credentials belong to the connection. peer answers only
	# while the handler runs, so the local scope ends with the
	# call.
	my $reply = do {
		local $self->{current_peer} =
		    $self->{peers}{ fileno $imsg->{fh} };

lib/Fugu/Control.pm  view on Meta::CPAN

	return 1;
}

# Fugu::Control->peer_supported:
#	Report if the platform gives peer credentials in the struct
#	sockpeercred order. A caller or a test uses this, not a log
#	line, to tell "not supported" from "the read failed".
sub peer_supported ($)
{
	return PEER_SUPPORTED ? 1 : 0;
}

# $self->peer:
#	The credentials of the connection that the server answers now,
#	as a hash reference with uid, gid and pid. The method returns
#	undef outside a handler call, and undef where peer_supported is
#	false. It holds no policy: the group of the socket is the
#	coarse gate, and the handler is the fine gate.
sub peer ($self)
{
	return $self->{current_peer};
}

# _read_peer($client):
#	The peer credentials of one connection, as ($peer, $fault).
#	One of the two is defined. getsockopt(2) with SO_PEERCRED
#	returns a struct sockpeercred, and the length check guards the
#	unpack.
sub _read_peer ($client)
{

 view release on metacpan or  search on metacpan

t/100_low/32_proxy_auth.t  view on Meta::CPAN

                    my ( $self, $headers, $request ) = @_;
                    my $auth = $self->proxy->hop_headers->header('Proxy-Authorization') || '';

                    my $request_uri = $request->uri->as_string;
                    my $token = $request_uri =~ m{/escape$} ? $token_escape : $token_simple;
                    # check the credentials
                    if ( $auth ne $token ) {
                        my $response = HTTP::Response->new(407);
                        $response->header( Proxy_Authenticate => 'Basic realm=
        +"HTTP::Proxy"' );
                        $self->proxy->response($response);

 view release on metacpan or  search on metacpan

t/000_env.t  view on Meta::CPAN

## test for presence of our test_environment_variables
if( $ENV{PERLSSH_HOST} ){
	if( $ENV{PERLSSH_USER} ){
		pass("PERLSSH host values seem to be sound." );
	}else{
		fail("do we have ssh credentials via ENV variables? (HOST is required! You can pass ENV vars like this: make test PERLSSH_HOST=example.com PERLSSH_PORT=port PERLSSH_USER=user)" );
		BAIL_OUT('Required ENV VARS declared!');
	}
}else{
	ok(1);
}

 view release on metacpan or  search on metacpan

lib/FusionInventory/Agent/HTTP/Client.pm  view on Meta::CPAN

        # authentication required
        if ($result->code() == 401) {
            if ($self->{user} && $self->{password}) {
                $logger->debug(
                    $log_prefix .
                    "authentication required, submitting credentials"
                );
                # compute authentication parameters
                my $header = $result->header('www-authenticate');
                my ($realm) = $header =~ /^Basic realm="(.*)"/;
                my $host = $url->host();
                my $port = $url->port() ||
                   ($scheme eq 'https' ? 443 : 80);
                $self->{ua}->credentials(
                    "$host:$port",
                    $realm,
                    $self->{user},
                    $self->{password}
                );

lib/FusionInventory/Agent/HTTP/Client.pm  view on Meta::CPAN

                    alarm 0;
                };
                if (!$result->is_success()) {
                    $logger->error(
                        $log_prefix .
                        "authentication required, wrong credentials"
                    );
                }
            } else {
                # abort
                $logger->error(
                    $log_prefix .
                    "authentication required, no credentials available"
                );
            }

        } elsif ($result->code() == 407) {
            $logger->error(
                $log_prefix .
                "proxy authentication required, wrong or no proxy credentials"
            );

        } else {
            # check we request through a proxy
            my $proxyreq = defined $result->request->{proxy};

 view release on metacpan or  search on metacpan

lib/FusqlFS/Backend/Base.pm  view on Meta::CPAN

These methods can be used to control database connection in runtime.
Please use them instead of direct DBH object access via $fusqlh->{dbh},
as they make some more work, than simple database {dis,re}connection.

They use credentials, provided on first backend object initialization
with L</new> method above, so no parameters are required.

C<connect> establish new database connection and reinitializes backend.
Backend reinitialization is required, because some backends make some
query preparation, linked to current database connection.

 view release on metacpan or  search on metacpan

bin/gbrowse_aws_balancer.pl  view on Meta::CPAN

=head1 CONFIGURING AWS CREDENTIALS

To work, the balancer script must be able to make spot instance
requests and to monitor and terminate instances. To perform these
operations the script must have access to the appropriate AWS
credentials (access key and secret key) on the command line or as
environment variables. 

While the script does its best to shield the credentials from prying
eyes, there is still a chance that the credentials can be intercepted
by another party with login access to the machine that the master runs
on and use the credentials to run up your AWS bill. For this reason
some people will prefer to create an EC2 account or role with limited
access to AWS resources.

=over 4

=item 1. Your personal EC2 credentials

You may provide the balancer script with --access_key and --secret_key
command line arguments using your personal EC2 credentials or set the
environment variables EC2_ACCESS_KEY and EC2_SECRET_KEY. If not
provided, the script will interactively prompt for one or both of
these values.

This is the simplest method, but has the risk that if the credentials
are intercepted by a malicious third party, he or she gains access to
all your EC2 resources.

=item 2. The credentials of a restricted IAM account

You may use the Amazon AWS console to create an IAM (Identity Access
and Management) user with restricted permissions, and provide that
user's credentials to the script on the command line or with
environment variables. The following IAM permission policy is the
minimum needed for the balancer script to work properly:

 {
  "Statement": [

bin/gbrowse_aws_balancer.pl  view on Meta::CPAN

    }
  ]
 }

Note that even with these restrictions, an unauthorized user with
access to the credentials could still launch a large number of spot
instances or terminate bona fide instances. This is just a fundamental
limitation of the granularity of EC2's permissions system.

=item 3. Create an IAM role

If the master is running on an EC2 instance, then the most convenient
way to pass credentials is by assigning the instance an IAM role. The
balancer script can then obtain temporary credentials by making
internal EC2 calls. The credentials do not need to be provided on the
command line or in environment variables, and are only valid for short
periods of time, limiting the effect of theft.

First, create an IAM role using the Amazon Console. Select
IAM->Roles->Create New Role, and give the role the name

 view release on metacpan or  search on metacpan

CONTRIBUTING  view on Meta::CPAN

=back

The C<-d> flag uses defaults where they match; you'll only be prompted for
the values that differ.

=item 3. Configure CPAN credentials (repo admin, one-time)

In GitHub, go to B<Settings → Secrets and variables → Actions> and add:

=over 4

 view release on metacpan or  search on metacpan

examples/oauth/generate_offline_credentials.pl  view on Meta::CPAN

# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This utility script demonstrate how to generate offline credentials for
# OAuth2 Installed Applications. The generated refresh token can then be used
# to configure the client library, refer to the OAuth2 section of the
# adwords.properties file. This example is meant to be run from the command line
# and requires user input.
#

examples/oauth/generate_offline_credentials.pl  view on Meta::CPAN

use Google::Ads::AdWords::Client;

use Cwd qw(abs_path);

# Main subroutine.
sub generate_offline_credentials {
  my ($client) = @_;

  my $auth_handler = $client->get_oauth_2_handler();

  print "Please enter your OAuth 2.0 Client ID and Client Secret.\n" .

examples/oauth/generate_offline_credentials.pl  view on Meta::CPAN

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Get AdWords Client, credentials will be read from ~/adwords.properties.
my $client = Google::Ads::AdWords::Client->new();

# Call the example
generate_offline_credentials($client);