CPAN::Groonga

nings;

package # hide from PAUSE for now
	Catalyst::Plugin::Flash::JSON;

our $VERSION = '0.002';

use JSON::MaybeXS;
my $jx = JSON::MaybeXS->new->ascii;

sub flash_to_cookie { shift; $jx->encode( \@

######

1;
__END__

=for stopwords
Allbery DocKnot MERCHANTABILITY NONINFRINGEMENT XDG sublicense JSON CPAN
ARGS Kwalify

=head1 NAME

App::DocKnot::Generate - Generate documentation from package meta

enerating consistent
human-readable software package documentation from metadata files, primarily
JSON and files containing documentation snippets.  It takes as input a
directory of metadata and a set

StoreConnect;

use 5.008;
use strict;
use warnings;

use Carp;
use Crypt::JWT qw(encode_jwt);
use JSON;

=head1 NAME

Apple::AppStoreConnect - Apple App Store Connect API client

=head1 VERSION

Versi

       params => \%query_params?
    );

Fetches the requested API url, by default, it will use L<JSON> to decode it
directly to a Perl hash, unless you request C<raw> result as a string.

Requires L<

2 C<jwt>

    my $jwt = $asc->jwt(
        iat => $iat?,
        exp => $exp?
    );

Returns the JSON Web Token string in case you need it. Will return a cached one
if it has more than 5 minutes unti

he \z }xms,
    qr{ \A Build \z }xms,
    qr{ \A MANIFEST[.]bak \z }xms,
    qr{ \A MYMETA [.] (?:json (?:[.]lock)? | yml) \z }xms,
    qr{ \A _build \z }xms,
    qr{ \A blib \z }xms,
    qr{ \A confi

##########

1;
__END__

=for stopwords
Allbery DocKnot MERCHANTABILITY NONINFRINGEMENT sublicense JSON CPAN ARGS
distdir Automake xz gpg Kwalify IO-Compress-Lzma

=head1 NAME

App::DocKnot::Dist - Pre

e configuration could look like this (for L<Kelp::Module::WebSocket::AnyEvent>):

	modules => [qw/JSON Symbiosis WebSocket::AnyEvent/],
	modules_init => {
		Symbiosis => {
			mount => undef, # kelp wi

f IO-Compress-Lzma), IO::Uncompress::Gunzip (part of
IO-Compress), IPC::Run, IPC::System::Simple, JSON::MaybeXS, Kwalify,
List::SomeUtils, Path::Iterator::Rule, Path::Tiny, Perl6::Slurp, Template
(par

erwise, Kwalify is unhappy with
    # data elements set to false.
    local $YAML::XS::Boolean = 'JSON::PP';

    # Load the metadata and check it against the schema.  YAML::XS for some
    # reason p

rnings;

use Carp qw(croak);
use JSON::MaybeXS qw(JSON);
use Kwalify qw(validate);
use Path::Iterator::Rule;
use Path::Tiny qw(path);
use YAML::XS ();

# The older JSON metadata format stored text sni

ey contains a slash, like
# foo/bar, it will be stored as a nested hash, as $data{foo}{bar}.
our @JSON_METADATA_FILES = qw(
    bootstrap
    build/middle
    build/suffix
    debian/summary
    packa

 test/suffix
);

##############################################################################
# JSON helper methods
##############################################################################

# 

        }
                $fh->print("\n");
            }
        }
    }
    1;
}

sub print_all_json {
    my ($self, $desc, $v, %opt) = @_;
    my ($indent, $fh, $skip_invalid) = @opt{qw(indent fh 

al_address => sub($mock) { $db->resultset("Address")->rand->single },
      address_json => sub($mock) { encode_json($mock->real_address) },
    },
    
    # load plugins
    plugins => ['Text'],  # 

use strict;
use warnings;
use Scalar::Util ();
use JSON ();

package Net::Correios::Manifestacao;

sub new {
    my ($class, $parent) = @_;
    Scalar::Util::weaken($parent);
    return bless { parent

      'POST',
        'pedido-informacao/v1/externo/pedidos/cadastra',
        { content => JSON::encode_json($request_data) }
    );
    return $parent->parse_response($res);
}

sub _traduz_embalagem

use strict;
use warnings;
use Scalar::Util ();
use JSON ();

package Net::Correios::Token;

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

    Scalar::Util::weaken($parent);
    return bless { parent => $p

nt = $self->{parent};

    my $endpoint_url = $parent->{base_url} . 'token/v1/autentica';
    my $json_body;
    # TODO: precisamos entender quais endpoints funcionam com quais tokens.
    # muito pro

;
        $json_body = JSON::encode_json({ numero => $args{contrato} });
    }
    elsif ($args{cartao}) {
        $endpoint_url .= '/cartaopostagem';
        $json_body = JSON::encode_json({ numero =

use warnings;

use HTTP::Tiny;
use MIME::Base64 ();
use Carp         ();
use Scalar::Util ();
use JSON         ();

$Carp::Internal{ 'Net::Correios' }++;

package Net::Correios;

our $VERSION = '0.002

         default_headers => {
                'Accept' => 'application/json',
                'Content-Type' => 'application/json',
            },
            verify_SSL => 1,
            timeout => $

b parse_response {
    my ($self, $res) = @_;
    if ($res->{success}) {
        my $data = JSON::decode_json($res->{content});
        return $data;
    }
    else {
        my $error = $res->{status

use strict;
use warnings;
use Scalar::Util;
use JSON ();

package Net::Correios::Prazo;

sub new {
    my ($class, $parent) = @_;
    Scalar::Util::weaken($parent);
    return bless { parent => $paren

equest(
        'cartao',
        'POST',
        'prazo/v1/nacional',
        { content => JSON::encode_json($args) }
    );
    my $res = $parent->parse_response($raw);
    foreach my $r (@$res) {
 

use strict;
use warnings;
use Scalar::Util ();
use JSON ();

package Net::Correios::Preco;

sub new {
    my ($class, $parent) = @_;
    Scalar::Util::weaken($parent);
    return bless { parent => $pa

equest(
        'cartao',
        'POST',
        'preco/v1/nacional',
        { content => JSON::encode_json($args) }
    );
    return $parent->parse_response($res);
}

sub _parse_nacional {
    my 

iagnostics;
use common::sense;

our $VERSION = "0.0.6";

use Aion::Format qw//;
use Aion::Format::Json qw//;
use B qw//;
use DBI qw//;
use Scalar::Util qw//;
use List::Util qw//;

use Exporter qw/impo

ned($v)? Aion::Format::Json::from_json($v): $v;
	}

	return remove("settings" => $id) if !defined $value;

	store('settings',
		id => $id,
		value => Aion::Format::Json::to_json($value),
	);
}

# во

      'cartao',
        'POST',
        'prepostagem/v1/prepostagens',
        { content => JSON::encode_json($request_data) }
    );
    return $parent->parse_response($res);
}

sub emitir_rotulo {
 

  'POST',
        'prepostagem/v1/prepostagens/rotulo/assincrono/pdf',
        { content => JSON::encode_json($request_data) }
    );
    return $parent->parse_response($res);
}

sub obter_rotulo_emit

package Geo::Coder::Postcodes;

use strict;
use warnings;

use Carp;
use Encode;
use JSON::MaybeXS;
use HTTP::Request;
use LWP::UserAgent;
use LWP::Protocol::https;
use URI;

=head1 NAME

Geo::Coder::

ned error: on $url " . $res->status_line());
		return;
	}

	my $json = JSON::MaybeXS->new()->utf8();

	# TODO: wantarray
	my $rc = $json->decode($res->decoded_content());
	my @results = @{$rc->{result

o API returned error: on $url " . $res->status_line());
		return;
	}

	my $json = JSON::MaybeXS->new->utf8();

	my $rc = $json->decode($res->content);
	if($rc->{'result'}) {
		my @results = @{$rc->{'r

atetime datetime2 datetimeoffset timestamp
	datetime_with_time_zone datetime_without_time_zone
	json jsonb
	uuid inet cidr macaddr
);
export(keys %type_generators);

# ABSTRACT: Collection of generato

our $json;
sub _json_encoder {
	$json //= do {
		local $@;
		my $mod= eval { require JSON::MaybeXS; 'JSON::MaybeXS' }
			  || eval { require JSON; 'JSON' }
			  || eval { require JSON::PP; 'JSON::PP'

 }
			or Carp::croak("No JSON module found.  This must be installed for the SQL::json generator.");
		$mod->new->canonical->ascii
	};
}

sub json {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? 

批

=cut

use strict;
use base qw(QQ::weixin::work);
use Encode;
use LWP::UserAgent;
use JSON;
use utf8;

our $VERSION = '0.10';
our @EXPORT = qw/ gettemplatedetail applyevent getapproval

    if ( @_ && $_[0] && ref $_[1] eq 'HASH' ) {
        my $access_token = $_[0];
        my $json = $_[1];
        my $ua = LWP::UserAgent->new;
        $ua->timeout(30);
        $ua->env_prox

oken=$access_token",Content => to_json($json,{allow_nonref=>1}),Content_type =>'application/json');
        if ($response->is_success) {
            return from_json($response->decoded_content,{utf8