view release on metacpan or  search on metacpan

lib/App/TimeTracker/Command/Jira.pm  view on Meta::CPAN

Username to connect with.

=head3 password [OPTIONAL]

Password to connect with. Beware: This is stored in clear text! Better use authentication via C<Config::Identity> via C<JIRA::REST> where the credentials can be stored GPG encrypted.

=head3 log_time_spent

If set, an entry will be created in the ticket's work log

 view release on metacpan or  search on metacpan

lib/App/Toot/Config.pm  view on Meta::CPAN

Returns a hashref of the loaded config for the defined section name.

=head1 CONFIGURATION

To post to Mastodon, you need to provide the account's oauth credentials in the file C<config.ini>.

An example is provided as part of this distribution.  The user running the L<toot> script, for example through cron, will need access to the configuration file.

To set up the configuration file, copy C<config.ini.example> into one of the following locations:

lib/App/Toot/Config.pm  view on Meta::CPAN

=item C</etc/toot/config.ini>

=back

After creating the file, edit and update the values in the C<default> section to match the account's oauth credentials.

 [default]
 instance = mastodon.social
 username = youruser
 client_id = OKE98_kdno_NOTAREALCLIENTID

 view release on metacpan or  search on metacpan

lib/App/TypecastTemplates.pm  view on Meta::CPAN

		if (!keys %$templates) {
			read_templates(\*DATA);
		}
	}
	open(my $handle, '<' . $fn)
		or die "can't open credentials file '$fn'";
	if ($columns) {
		$csv->column_names( split(/,/,$columns) );
	}
	else {
		my @cols = $csv->getline( $handle );

 view release on metacpan or  search on metacpan

lib/App/Validation/Automation/Web.pm  view on Meta::CPAN

Stores utilities that perform web based validation

=head1 SYNOPSIS

App::Validation::Automation::Web browses the web urls stored in config or passed as arguments using WWW::Mechanize Logs into the web urls using the credentials stored in attributes.Handles password expiry and authentication failure along with DNS rou...

=head1 ATTRIBUTES

user_name houses the login name needed to login into the web url.password stores the decrypted password.

 view release on metacpan or  search on metacpan

lib/App/WatchLater/YouTube.pm  view on Meta::CPAN

=head1 SYNOPSIS

This is a simple module for making requests to the YouTube Data API.
Authorization is required, and can be obtained by registering for an API key
from the Google Developer L<API
Console|https://console.developers.google.com/apis/credentials>. Alternatively,
obtain user authorization through OAuth2 using the yt-oauth(1) script.

    my $api = App::WatchLater::YouTube->new(
        access_token => ...,
        api_key      => ...,

 view release on metacpan or  search on metacpan

script/wp-tools  view on Meta::CPAN

            $database =~ s/^[\r\n]+//;
            chomp $username;
            chomp $password;
            chomp $database;
            if ($username =~ /[\r\n]/ || $password =~ /[\r\n]/ || $database =~ /[\r\n]/) {
                die "Multiple credentials found in $args->{'path'}/wp-config.php.  Cannot determine which to use.  Backup operation halted.";
            }
            open (my $fh, '>', $defaults_file) or die "Cannot write to $defaults_file: $!";
            close $fh;
            chmod(0600, $defaults_file) or die "Cannot chmod $defaults_file: $!";
            write_text($defaults_file,"[client]\nuser=$username\npassword=$password");

script/wp-tools  view on Meta::CPAN

                $database =~ s/^[\r\n]+//;
                chomp $username;
                chomp $password;
                chomp $database;
                if ($username =~ /[\r\n]/ || $password =~ /[\r\n]/ || $database =~ /[\r\n]/) {
                    die "Multiple credentials found in $args->{'path'}/wp-config.php.  Cannot determine which to use.  Restoration operation halted.";
                }
                open (my $fh, '>', $defaults_file) or die "Cannot write to $defaults_file: $!";
                close $fh;
                chmod(0600, $defaults_file) or die "Cannot chmod $defaults_file: $!";
                write_text($defaults_file,"[client]\nuser=$username\npassword=$password");

script/wp-tools  view on Meta::CPAN

        $database =~ s/^[\r\n]+//;
        chomp $username;
        chomp $password;
        chomp $database;
        if ($username =~ /[\r\n]/ || $password =~ /[\r\n]/ || $database =~ /[\r\n]/) {
            die "Multiple credentials found in $args->{'path'}/wp-config.php.  Cannot determine which to use.  Upgrade operation halted.";
        }
        if ($prefix =~ /[\r\n]/) {
            die "Multiple database prefixes found in $args->{'path'}/wp-config.php.  Cannot determine which to use.  Upgrade operation halted.";
        }
        open (my $fh, '>', $defaults_file) or die "Cannot write to $defaults_file: $!";

 view release on metacpan or  search on metacpan

lib/App/ZofCMS/Plugin/UserLogin.pm  view on Meta::CPAN

B<Optional>. Takes a scalar as a value that represents a query parameter
name into which to store the URI of the page that not-logged-in  user
attempted to access. This option works only when C<redirect_on_login> is
specified. When specified, plugin enables the magic to "remember" the page
that a not-logged-in user tried to access, and once the user enters correct
login credentials, he is redirected to said page automatically; thereby
making the login process transparent. B<By default> is not specified.

=head2 C<preserve_login>

    preserve_login => 'my_site_login',

 view release on metacpan or  search on metacpan

lib/App/coinbasepro/lite.pm  view on Meta::CPAN

        schema => 'str*',
        default => 'GET',
    },
);

my %args_credentials = (
    key => {
        schema => ['str*'],
        req => 1,
    },
    secret => {

lib/App/coinbasepro/lite.pm  view on Meta::CPAN

$SPEC{private} = {
    v => 1.1,
    summary => 'Perform a public API request',
    args => {
        %args_credentials,
        %args_common,
    },
};
sub private {
    my %args = @_;

 view release on metacpan or  search on metacpan

lib/App/cryp/Role/Exchange.pm  view on Meta::CPAN

You have to specify one of base_size or quote_size, but not both.

=back

Some specific exchanges might require more credentials or arguments (e.g.
C<api_passphrase> on Coinbase Pro); please check with the specific drivers.

When successful, payload in response must be a hashref which contains at least
these keys: C<type> ("buy" or "sell"), C<pair>, C<order_id> (str, usually a
number, can also be a UUID, etc), C<price> (number, actual price of the order),

lib/App/cryp/Role/Exchange.pm  view on Meta::CPAN

String. Required.

=back

Some specific exchanges might require more credentials or arguments (e.g.
C<api_passphrase> on GDAX); please check with the specific drivers.

Method must return object.

=head1 HOMEPAGE

 view release on metacpan or  search on metacpan

lib/App/gcal.pm  view on Meta::CPAN

            require Net::Netrc;
            my $netrc = Net::Netrc->lookup('google.com');

            unless ($netrc) {
                die(
                    'Error. Could not find your credentials in your .netrc file'
                );
            }

            $username = $netrc->login;
            $password = $netrc->password;

lib/App/gcal.pm  view on Meta::CPAN

=head1 DESCRIPTION

The C<gcal> command provides a quick and easy interface to Google Calendar from the command line.

Before using the C<gcal> command, you need to provide your Google credentials. The most convenient way to do this is by using your C<~.netrc> file and supplying credentials for the C<google.com> machine. For example:

  machine google.com
  login bill
  password 1234

 view release on metacpan or  search on metacpan

lib/App/gh/Command/Fork.pm  view on Meta::CPAN

	my $gh_id = App::gh->config->github_id;
	my $gh_token = App::gh->config->github_token 
        || App::gh->config->github_password;
    unless( $gh_id && $gh_token ) {
        die "Github credentials not found. Cannot fork repository.\n";
    }


    unless ( $repo ) {
        # detect .git directory

 view release on metacpan or  search on metacpan

lib/App/gist.pm  view on Meta::CPAN

	around _request_for => sub {
		my ($orig, $self, @args) = @_;
		my $req = $self -> $orig(@args);

		my ($login, $passwd) = App::gist::_get_credentials();

		$req -> headers -> remove_header('Authorization');
		$req -> headers -> authorization_basic($login, $passwd);

		return $req;

lib/App/gist.pm  view on Meta::CPAN

			}
		}
	);
}

sub _get_credentials {
	my ($login, $pass, $token);

	my %identity = Config::Identity::GitHub -> load
		if try_load_class('Config::Identity::GitHub');

 view release on metacpan or  search on metacpan

lib/App/git/ship.pm  view on Meta::CPAN

The main focus is to automate away the boring steps, but at the same time not
get in your (or any random contributor's) way. Problems should be solved with
sane defaults according to standard rules instead of enforcing more rules.

L<App::git::ship> differs from other tools like L<dzil|Dist::Zilla> by I<NOT>
requiring any configuration except for a file containing the credentials for
uploading to CPAN.

=head2 Supported project types

Currently, only L<App::git::ship::perl> is supported.

 view release on metacpan or  search on metacpan

lib/App/html2wp.pm  view on Meta::CPAN

    v => 1.1,
    summary => 'Publish HTML document to WordPress as blog post',
    description => <<'_',

To use this program, first create `~/html2wp.conf` containing the API
credentials, e.g.:

    proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME
    password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

    [profile=blog1]
    proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME

lib/App/html2wp.pm  view on Meta::CPAN

 html2wp(%args) -> [status, msg, payload, meta]

Publish HTML document to WordPress as blog post.

To use this program, first create C<~/html2wp.conf> containing the API
credentials, e.g.:

 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

 [profile=blog1]
 proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME

 view release on metacpan or  search on metacpan

lib/App/org2wp.pm  view on Meta::CPAN

This is originally a quick hack because I couldn't make
[org2blog](https://github.com/punchagan/org2blog) on my Emacs installation to
work after some update. `org2wp` uses the same format as `org2blog`, but instead
of being an Emacs package, it is a CLI script written in Perl.

First, create `~/org2wp.conf` containing the API credentials, e.g.:

    ; use INI (IOD) format for this file
    proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME
    password=YOURPASSWORD

lib/App/org2wp.pm  view on Meta::CPAN

server, which can be hosted on `wordpress.com` or on other server, including
your own. It has nothing to do with HTTP/HTTPS proxy; the term "proxy" is used
by the <pm:XMLRPC::Lite> and <pm:SOAP::Lite> Perl libraries and `org2wp` simply
uses the same terminology.

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

    ; use INI (IOD) format for this file
    [profile=blog1]
    proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php

lib/App/org2wp.pm  view on Meta::CPAN

This is originally a quick hack because I couldn't make
LL<https://github.com/punchagan/org2blog> on my Emacs installation to
work after some update. C<org2wp> uses the same format as C<org2blog>, but instead
of being an Emacs package, it is a CLI script written in Perl.

First, create C<~/org2wp.conf> containing the API credentials, e.g.:

 ; use INI (IOD) format for this file
 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

lib/App/org2wp.pm  view on Meta::CPAN

server, which can be hosted on C<wordpress.com> or on other server, including
your own. It has nothing to do with HTTP/HTTPS proxy; the term "proxy" is used
by the L<XMLRPC::Lite> and L<SOAP::Lite> Perl libraries and C<org2wp> simply
uses the same terminology.

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

 ; use INI (IOD) format for this file
 [profile=blog1]
 proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php

 view release on metacpan or  search on metacpan

lib/App/pepper.pm  view on Meta::CPAN

my $handlers = {
    'timeout'        => \&handle_timeout,
    'ssl'            => \&handle_ssl,
    'host'            => \&handle_host,
    'port'            => \&handle_port,
    'credentials'    => \&handle_credentials,
    'id'            => \&handle_id,
    'pw'            => \&handle_pw,
    'newpw'            => \&handle_newpw,
    'connect'        => \&handle_connect,
    'login'            => \&handle_login,

lib/App/pepper.pm  view on Meta::CPAN

        }
        return $result;
    }
}

sub handle_credentials {
    if ($_[0] eq '') {
        return error('Missing client ID');

    } elsif ($_[1] eq '') {
        return error('Missing password');

lib/App/pepper.pm  view on Meta::CPAN

    } elsif ($epp->{'host'} eq '') {
        return error('No host specified');

    } elsif ($epp->{'user'} eq '' || $epp->{'pass'} eq '') {
        return error('No credentials specified');

    } else {
        note("Attempting to login as '%s'...", $epp->{'user'});
        $epp->{'quiet'} = ($verbose ? 0 : 1);
        my $result = $epp->_login;

lib/App/pepper.pm  view on Meta::CPAN

    my %map = (
        'timeout'            => 'SYNTAX/Connection Management',
        'ssl'                => 'SYNTAX/Connection Management',
        'host'                => 'SYNTAX/Connection Management',
        'port'                => 'SYNTAX/Connection Management',
        'credentials'        => 'SYNTAX/Session Management',
        'id'                => 'SYNTAX/Session Management',
        'pw'                => 'SYNTAX/Session Management',
        'newpw'                => 'SYNTAX/Session Management',
        'connect'            => 'SYNTAX/Connection Management',
        'login'                => 'SYNTAX/Session Management',

 view release on metacpan or  search on metacpan

t/features/step_definitions/basic.pl~  view on Meta::CPAN

use warnings;

use lib 't/lib';
use Test::Helper qw(testmojo create_user testschema);
use Test::StepsHelper
  qw(a_login_request_with_invalid_credentials get_result api_base );
use Test::Net::LDAP::Util qw(ldap_mockify);

use Test::More;
use Test::BDD::Cucumber::StepFile;

t/features/step_definitions/basic.pl~  view on Meta::CPAN

        create_user( context => $context );
    };
};

When qr{the client tries to login without providing a user name} => sub {
    my $request = a_login_request_with_invalid_credentials();
    delete $request->{username};
    $t->post_ok( $route => $accept_header => json => $request );
};

When qr{the client tries to login without providing a password} => sub {
    my $request = a_login_request_with_invalid_credentials();
    delete $request->{password};
    $t->post_ok( $route => $accept_header => json => $request );
};

When
qr{the client tries to log in providing correct password for this existing user}
  => sub {
    my $request = a_login_request_with_invalid_credentials();
    $request->{username} = C->stash->{scenario}->{username};
    $request->{password} = C->stash->{scenario}->{password};

    # deep within this login there's a bind() which we have to mock
    ldap_mockify {
      $t->post_ok( $route => $accept_header => json => $request );
    }
  };

When qr{the client tries to login providing name of non-existing user} => sub {
    my $request = a_login_request_with_invalid_credentials();
    $request->{username} = 'I do not exist';
    $t->post_ok( $route => $accept_header => json => $request );
};

When

 view release on metacpan or  search on metacpan

lib/App/pod2wp.pm  view on Meta::CPAN

This is like <prog:org2wp> except that instead of Org as the document format,
this program uses POD.

To use this program, first create `~/pod2wp.conf` containing the API
credentials, e.g.:

    proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME
    password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

    [profile=blog1]
    proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME

lib/App/pod2wp.pm  view on Meta::CPAN

This is like L<org2wp> except that instead of Org as the document format,
this program uses POD.

To use this program, first create C<~/pod2wp.conf> containing the API
credentials, e.g.:

 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

 [profile=blog1]
 proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME

 view release on metacpan or  search on metacpan

lib/App/rdapper.pm  view on Meta::CPAN

=item * C<--short> - omit remarks, notices, links and redactions.

=item * C<--bypass-cache> - disable local cache of RDAP objects.

=item * C<--auth=USER:PASS> - HTTP Basic Authentication credentials to be used
when accessing the specified resource. This option B<SHOULD NOT> be used unless
you explicitly specify a URL, otherwise your credentials may be sent to servers
you aren't expecting them to.

=item * C<--nocolor> - disable ANSI colors in the formatted output.

=item * C<--debug> -run in debugging mode.

 view release on metacpan or  search on metacpan

tpnotify  view on Meta::CPAN

=item B<smtp://>[I<USER>[B<:>I<PASS>]B<@>]I<HOSTNAME>[B<:>I<PORT>]

Send mail using SMTP.  I<HOSTNAME> is the hostname or IP address of the mail
relay to use.  I<PORT>, if supplied, is the port number to use instead of the
default 25.  Optional I<USER> and I<PASS> provide credentials, if the relay
requires authentication.

=back

=item B<-n>, B<--dry-run>

 view release on metacpan or  search on metacpan

bin/wp-xmlrpc  view on Meta::CPAN

This document describes version 0.003 of wp-xmlrpc (from Perl distribution App-wp-xmlrpc), released on 2017-04-24.

=head1 SYNOPSIS

In C<~/wp-xmlrpc.conf>, put your API credentials:

 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

Then:

 % wp-xmlrpc wp.getPost 13

You can also put multiple credentials in the config file via profiles:

 [profile=blog1]
 proxy=https://BLOG1NAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

 view release on metacpan or  search on metacpan

lib/App/wsgetmail.pm  view on Meta::CPAN

=over

=item Client Credentials

This method uses shared secrets and is preferred by Microsoft.
(See L<Client credentials|https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-authentication-flows#client-credentials>)

=item Username/password

This method is more like previous connections via IMAP. It is currently
supported by Microsoft, but not recommended. (See L<Username/password|https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-authentication-flows#usernamepassword>)

lib/App/wsgetmail.pm  view on Meta::CPAN

    wsgetmail --config=wsgetmail.json --options='{"folder": "Inbox"}'
    wsgetmail --config=wsgetmail.json --options='{"folder": "Other Folder"}'

NOTE: Setting C<secret> or C<user_password> with C<--options> is not secure
and may expose your credentials to other users on the local system. If you
need to set these options, or just change a lot of settings in your
configuration, just run wsgetmail with different configurations:

    wsgetmail --config=account01.json
    wsgetmail --config=account02.json

 view release on metacpan or  search on metacpan

lib/ArangoDB2.pm  view on Meta::CPAN

{
    my($self, $name) = @_;
    # default database for arango is _system
    $name ||= "_system";
    # only create one instance per ArangoDB2 per database, each ArangoDB2
    # keeps its own instances since they may have different credentials
    return $self->databases->{$name} ||= ArangoDB2::Database->new($self, $name);
}

# databases
#

 view release on metacpan or  search on metacpan

lib/Arepa/Web/Auth.pm  view on Meta::CPAN

use MojoX::Session;

# Let session cookies live one week
use constant TTL_SESSION_COOKIE => 60 * 60 * 24 * 7;

sub _check_credentials {
    my ($self, $username, $password, $auth_type) = @_;

    if (defined $auth_type && $auth_type eq 'file_md5') {
        my $user_file_path =
          $self->config->get_key('web_ui:authentication:user_file');

lib/Arepa/Web/Auth.pm  view on Meta::CPAN

        if (defined $self->param('username') &&
                defined $self->param('password')) {
            my $valid_creds;
            eval {
                $valid_creds =
                  $self->_check_credentials($self->param('username'),
                                            $self->param('password'),
                                            $auth_type);
            };
            if ($EVAL_ERROR) {
                $self->vars("error" => $EVAL_ERROR);

 view release on metacpan or  search on metacpan

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

	if ( !$result->is_success() ) {

		# authentication required
		if ( $result->code() == 401 ) {
			if ( $self->{user} && $self->{password} ) {
				$logger->debug( $log_prefix . "authentication required, submitting credentials" );

				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} );

				# replay request
				eval {
					if ( $OSNAME eq 'MSWin32' && $scheme eq 'https' ) {
						alarm $self->{ua}->{timeout};
					}
					$result = $self->{ua}->request( $request, $file );
					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" );
			}
		}
		else {
			$logger->error( $log_prefix . "communication error: " . $result->status_line() );
		}

 view release on metacpan or  search on metacpan

lib/ArrayData/Lingua/Word/EN/Enable.pm  view on Meta::CPAN

credentialing
credentialism
credentialisms
credentialled
credentialling
credentials
credenza
credenzas
credibilities
credibility
credible

 view release on metacpan or  search on metacpan

lib/ArrayData/Word/EN/Enable.pm  view on Meta::CPAN

credentialing
credentialism
credentialisms
credentialled
credentialling
credentials
credenza
credenzas
credibilities
credibility
credible

 view release on metacpan or  search on metacpan

lib/Articulate/Authentication.pm  view on Meta::CPAN

use warnings;

use Moo;
with 'Articulate::Role::Component';

use Articulate::Syntax qw(new_credentials instantiate_array);

=head1 NAME

Articulate::Authentication - determine if a user who they claim to be

lib/Articulate/Authentication.pm  view on Meta::CPAN

      Articulate::Authentication:
        providers:
          - Articulate::Authentication::AlwaysAllow

  # then any component can dp
  $component->authentication->login($credentials);
  $component->authentication->login($user_id, $password);

=head1 ATTRIBUTE

=head3 providers

lib/Articulate/Authentication.pm  view on Meta::CPAN

  coerce  => sub { instantiate_array(@_) },
);

=head3 login

  $authentication->login($credentials);
  $authentication->login( $user_id, $password );

Asks each provider if the credentials supplied match a known user.
Credentials may be in whatever form will satisfy the C<credentials>
function in L<Articulate::Credentials> (username and password, hashref
or credentials object).

Each provider must respond true, false, or undef. A true value means
the user is authenticated. A false value means that the user exists but
is explicitly refused access (this should only be used in exceptional
circumstances) and an undef value means the user cannot be

lib/Articulate/Authentication.pm  view on Meta::CPAN

=cut

sub login {
  my $self        = shift;
  my $credentials = new_credentials @_;
  foreach my $provider ( @{ $self->providers } ) {
    return $credentials if $provider->authenticate($credentials);
    return $credentials if $credentials->rejected;
  }
  return $credentials->deny('No provider authenticated these credentials');
}

=head3 create_user

  $authentication->create_user( $user_id, $password );

 view release on metacpan or  search on metacpan

lib/Artifactory/Client.pm  view on Meta::CPAN

}

=head2 push_docker_tag_to_bintray( dockerImage => 'jfrog/ubuntu:latest', async => 'true', ... )

Push Docker tag to Bintray.  Calculation can be synchronous (the default) or asynchronous.  You will need to enter your
Bintray credentials, for more details, please refer to Entering your Bintray credentials.

=cut

sub push_docker_tag_to_bintray {
    my ( $self, %args ) = @_;

lib/Artifactory/Client.pm  view on Meta::CPAN

    return $self->post($url);
}

=head2 retrieve_all_available_plugin_info

Retrieves all available user plugin information (subject to the permissions of the provided credentials)

=cut

sub retrieve_all_available_plugin_info {
    my $self = shift;
    return $self->_handle_plugins();
}

=head2 retrieve_plugin_info_of_a_certain_type( $type )

Retrieves all available user plugin information (subject to the permissions of the provided credentials) of the
specified type

=cut

sub retrieve_plugin_info_of_a_certain_type {