CPAN::Groonga

$self }
      }
    }
    if ( delete $options->{ to_json } ) {
      no strict 'refs'; ## no critic ( ProhibitNoStrict )
      *{ "$class\::TO_JSON" } = sub { $_[ 0 ]->name }
    }
  }

  croak "Unkn

/json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json

tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $he

tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $he

tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $he

ngGrafanacloudlogsAdditional;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{

tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $he

#x60; access scoped to your Loki instance. (optional)
# @param string $index The Stream Labels, a JSON string used to identify the stream. (optional)
{
    my $params = {
    'service_id' => {
       

  },
    'index' => {
        data_type => 'string',
        description => 'The Stream Labels, a JSON string used to identify the stream.',
        required => '0',
    },
    };
    __PACKAGE__->met

tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $he

erged into the user specified in the request body.

B<Request Format:>

Content-Type: application/json

    {
        "User": "target_user_id_or_name"
    }

The C<User> field is required and can be e

23/merge \
         -H "Authorization: token YOUR_TOKEN" \
         -H "Content-Type: application/json" \
         -d '{"User": "456"}'

=head2 POST /user/{id}/unmerge

Unmerge users that have been me

alled with an empty JSON body or no C<User> parameter, this will unmerge
ALL users that have been merged into the specified user.

B<Request Format:>

Content-Type: application/json

    {}

B<Respons

1_hex);
use File::Basename;
use File::ShareDir qw(dist_file);
use File::Spec;
use IPC::Open3;
use JSON::PP ();

our $VERSION = '1.03';
$VERSION =~ tr/_//d;    ## no critic

use constant DEBUG => $ENV{

vent|iife)$/);

    my $json = JSON::PP->new;

    $json->utf8->canonical->allow_nonref->allow_unknown->allow_blessed->convert_blessed->escape_slash(0);

    my $option = $json->encode($self->options)

};

        $option =~ s/$search/$replace/;

    }

    my @script = ();

    my $init_options = $json->encode({locale => $locale, renderer => $renderer});

    my $extra_script = '';
    my $chart_ev

ult;
                if ($res->is_success) {
                    return ok($res->json);  # Success case with parsed JSON
                } else {
                    return err({            # Error ca

etch a specific todo item
    sub fetch_todo {
        my $id = shift;
        my $uri = "https://jsonplaceholder.typicode.com/todos/${id}";
        fetch_result($uri);
    }

    # Fetch multiple tod

    my $request = $clinet->req;

Returns Mojo::Message::Request object

=head2 request

    my $json = $clinet->request("METHOD", "PATH", ...ATTRIBUTES...);

Send request

=head2 res

    my $respon

fig.io/all.json'));

    # Socks5
    my $status = $client
        ->proxy('socks://socks:socks@192.168.201.129:1080')
        ->request(GET => $client->str2url('http://ifconfig.io/all.json'));

Direc

ks:socks@192.168.201.129:1080')
        ->request(GET => $client->str2url('http://ifconfig.io/all.json'));

=head1 DEPENDENCIES

L<Mojolicious>, L<Mojo::UserAgent>

=head1 TO DO

See C<TODO> file

=he

 mostly useful when your work project has its own boilerplate module.

It can also be provided as JSON or YAML in the environment variable
PPI_CUSTOM_FEATURE_INCLUDES, like so:

  PPI_CUSTOM_FEATURE_I

has _json => (
    is      => 'ro',
    isa     => Bool,
    lazy    => 1,
    default => sub {
        my $self = shift;
        return defined $self->_opts->json
            ? $self->_opts->json
   

ignore. One per line.'
        ],
        [],
        [
            'json',
            '(Experimental) Emit linting results as JSON rather than plain text'
        ],
        [],
        [
          

onfig_file };

        # The Bool type provided by Types::Standard doesn't seem to like
        # JSON::PP::Boolean
        for my $key ( keys %config ) {
            my $maybe_bool = $config{$key};
 

e' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/vnd.api+json');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept;
    }
    $he

use strict;
use warnings;

use Cpanel::JSON::XS 4.19 qw( encode_json );
use Getopt::Long 2.40 qw();
use LWP::UserAgent 5.00;
use Test::Script 1.27 qw(
    script_compiles
    script_runs
    script_st

derr_is
    script_stderr_like
);

my $foo = decode_json( { foo => 'bar' } );
my @foo = GetOptions();

script_compiles();
script_runs();
script_stderr_is();
script_stderr_like();

ly::Object::Serviceusagetype;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{

ject::ListDashboardsResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{

::Object::EomInvoiceResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{

ertyDataSourcePropertyConfig;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{

e::Fastly::Object::Dashboard;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{

ionshipTlsDnsRecordsResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON::MaybeXS qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

f = shift;
    my $_hash = decode_json(JSON()->new->allow_blessed->convert_blessed->encode($self));

    return $_hash;
}

# used by JSON for serialization
sub TO_JSON {
    my $self = shift;
    my $

serialize the data
    while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
        my $_json_attribute = $self->attribute_map->{$_key};
        my $_is_nullable = ($self->openapi_nullable->{