CPAN::Groonga

 eq 'JSON::Color') {
        require JSON::Color;
        if    ($_action eq 'dd'     ) { print  JSON::Color::encode_json(\@_)."\n"; return @_ }
        elsif ($_action eq 'dd_warn') { warn   JSON::Co

de_json(\@_)."\n"; return @_ }
        elsif ($_action eq 'dd_warn') { die    JSON::Color::encode_json(\@_)."\n"            }
        elsif ($_action eq 'dmp'    ) { return JSON::Color::encode_json(\@

 'JSON::MaybeXS') {
        require JSON::MaybeXS;
        if    ($_action eq 'dd'     ) { print  JSON::MaybeXS::encode_json(\@_)."\n"; return @_ }
        elsif ($_action eq 'dd_warn') { warn   JSON:

package Devel::QuickCover::Report;

use strict;
use warnings;

use JSON::MaybeXS qw(encode_json   decode_json);
use Sereal        qw(encode_sereal decode_sereal);
use Path::Tiny    qw(path);

sub new 

->{changes} = 0;
}

sub merge {
    my ($self, $file) = @_;

    my $json = path($file)->slurp;
    my $decoded = decode_json($json);
    my $files = $self->{data}{files};
    my $subs = $self->{data}

package JavaScript::V8::XS;
use strict;
use warnings;
use parent 'Exporter';

use JSON::PP;
use Text::Trim qw(trim rtrim);
use XSLoader;

our $VERSION = '0.000014';
XSLoader::load( __PACKAGE__, $VERSI

VERSION

use 5.010001;
use strict;
use warnings;
use experimental 'smartmatch';

use JSON::MaybeXS;
my $json = JSON::MaybeXS->new->allow_nonref;

use parent qw(Perinci::Access::Schemeless);

sub new {

 {},
            $req->{-perl_package}, $leaf);
        if ($meta) {
            $req->{-meta} = $json->decode($meta);
        } else {
            return [404, "No metadata found in database for pack

ame=?", {},
            $req->{-perl_package});
        if ($meta) {
            $req->{-meta} = $json->decode($meta);
        } else {
            $req->{-meta} = {v=>1.1}; # empty metadata for /
   

d::Auth::ServiceAccount;
use LWP::UserAgent;
use HTTP::Request;
use URI;
use URI::QueryParam;
use JSON::XS;

our $VERSION = "0.01";

has base_url => (
    is => 'ro',
    isa => 'Str',
    default => 

t-Type' => 'application/json; charset=utf8');
    $req->header('Authorization' => 'Bearer ' . $self->auth->get_token);
    if ($content) {
        my $encoded_body = encode_json($content);
        $re

    }

    my $res = $self->ua->request($req);

    if ($res->is_success) {
        return decode_json($res->content);
    }
    else {
        die "Fail: " . $res->content;
    }
}

sub request_get {

e::ILS>

=cut

use Carp;
use HTTP::Request::Common;
use URI::Escape;
use JSON qw(to_json);

use parent qw(WebService::ILS::JSON);

use constant API_VERSION => "v1";
use constant BASE_DOMAIN => "rbdigi

user_agent->request( $request );
    $self->check_response($response);

    return $self->process_json_response($response, sub {
        my ($data) = @_;
        die "No data\n" unless $data;
        

 $self->_request_with_auth($request);
    unless ($response->is_success) {
        $self->process_json_error_response($response, sub {
            my ($data) = @_;
            if (my $message = $data-

Log::ger;

sub action_self_upgrade {
    require File::Which;
    require HTTP::Tiny;
    require JSON::MaybeXS;

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

    unless (File::Which::which("cpanm")) {
        return [4

val { $apires = JSON::MaybeXS::decode_json($apires->{content}) };
        if ($@) {
            warn "Cannot upgrade module '$module': Invalid API response from $apiurl: not valid JSON: $@\n";
       

ILS>

=cut

use Carp;
use HTTP::Request::Common;
use URI::Escape;

use parent qw(WebService::ILS::JSON);

use constant API_VERSION => "v1";

use constant DISCOVERY_API_URL => "http://api.overdrive.com

_request(\&_basic_callback, $url, $get_params);
}

sub _error_from_json {
    my $self = shift;
    my $data = shift or croak "No json data";
    my $error = join " ", grep defined($_), $data->{errorC

package WebService::ILS::XML;

use Modern::Perl;

=encoding utf-8

=head1 NAME

WebService::ILS::JSON - WebService::ILS module for services with XML API

=head1 DESCRIPTION

To be subclassed

See L<We

> $self->library_id,
    );
    my $req = HTTP::Request::Common::POST( $url );
    return $self->_json_request_content($req, \%params);
}

sub title_url {
    my $self = shift;
    my $isbn = shift or

e::CloudTasks->client(
        version => 'v2',
        credentials_path => '/path/to/credentials.json',
    );

    #  Create task
    my $project_id = 'myproject';
    my $location_id = 'asia-northe

=head2 AUTHENTICATION

A service account with appropriate roles is required. You need to download JSON file and specify C<credentials_path>.
See also: L<https://cloud.google.com/docs/authentication/ge

s_path => '/path/to/credentials.json',
    );

C<version> is an API version. (Currently only C<v2> is available)
C<credentials_path> is a path to a service account JSON file.

=head2 Location

Refer t

ams::Check;
use LWP::UserAgent;
use HTTP::Status qw(:constants);
use MIME::Base64 qw();
use JSON qw(from_json);

our $DEBUG;

my %CONSTRUCTOR_PARAMS_SPEC;
sub _set_param_spec {
    my $class = shift;

 = $self->user_agent->request( $request );
    # XXX check content type
    return $self->process_json_response(
        $response,
        sub {
            my ($data) = @_;

            my ($token, 

{
            my ($data) = @_;

            die join "\n", ERROR_ACCESS_TOKEN, $self->_error_from_json($data) || $response->decoded_content;
        }
    );
}

sub _access_auth_string {
    my $self 

 => "true"};
    }

    my $url = $self->circulation_action_url("/holds");
    return $self->with_json_request(
        \&_basic_callback,
        sub {
            my ($data) = @_;
            if ($d

       }
    }

    my $url = $self->circulation_action_url("/checkouts");
    return $self->with_json_request(
        \&_basic_callback,
        undef,
        $url,
        {fields => _build_checko

   my $url = $self->circulation_action_url("/checkouts/$item_id/formats");
    return $self->with_json_request(
        \&_basic_callback,
        sub {
            my ($data) = @_;
            die "$

ERSION = '0.1.9';
use strict;
use warnings;
use 5.010;

use parent qw(Device::Firewall::PaloAlto::JSON);

use Device::Firewall::PaloAlto::Op::GlobalCounter;
use Device::Firewall::PaloAlto::Errors qw(E

new module

use Device::Firewall::PaloAlto::Op::Route;

use parent qw(Device::Firewall::PaloAlto::JSON);


sub _new {
    my $class = shift;
    my ($api_return) = @_;
    my %virtual_router;

    # R

ODNAME
# ABSTRACT: Palo Alto IP to user mapping entry.

use parent qw(Device::Firewall::PaloAlto::JSON);


sub _new {
    my $class = shift;
    my ($api_response) = @_;
    my %userid_entry = %{$api_

se Device::Firewall::PaloAlto::Errors qw(fatal_error);

use parent qw(Device::Firewall::PaloAlto::JSON);

use List::Util qw(first);
use Class::Error;

# VERSION
# PODNAME
# ABSTRACT: new module


sub 

ION
# PODNAME
# ABSTRACT: Palo Alto firewall ARP entry

use parent qw(Device::Firewall::PaloAlto::JSON);


sub _new {
    my $class = shift;
    my ($api_return) = @_;

    # Clean up the status field

ERSION = '0.1.9';
use strict;
use warnings;
use 5.010;

use parent qw(Device::Firewall::PaloAlto::JSON);

use Device::Firewall::PaloAlto::Op::IPUserMap;
use Device::Firewall::PaloAlto::Errors qw(ERROR

ERSION
# PODNAME
# ABSTRACT: Palto Alto firewall route

use parent qw(Device::Firewall::PaloAlto::JSON);

use Regexp::Common qw(net);


sub _new {
    my $class = shift;
    my ($api_return) = @_;