CPAN::Groonga

::ContactGroup;
use JMAP::Validation::Checks::Error;
use JMAP::Validation::Generators;
use JSON::PP;
use JSON::Typist;
use Test2::Bundle::Extended;
use Test::Deep qw{eq_deeply};

my (
  %ACCOUNT,
  $S

mit') {
    $request_args{accountId} = {
      supplied => $ACCOUNT{accountId},
      null     => JSON::PP::null,
    }->{$test->{accountId}};
  }

  unless ($test->{ids} eq 'omit') {
    $request_arg

l_not_found  => [qw{these ids do not exist}],
      empty          => [],
      null           => JSON::PP::null,
    }->{$test->{ids}};
  }

  return \%request_args;
}

sub _build_error_response {
  

package JMAP::Validation::Tests::Boolean;

use strict;
use warnings;

sub is_boolean{
  my ($value) = @_;

  return (ref($value) || '') eq 'JSON::PP::Boolean';
}

1;

::Generators::SetError;

use strict;
use warnings;

use JMAP::Validation::Generators::String;
use JSON::Typist;

my %types = (
  invalidArguments => {
    description => JMAP::Validation::Generators::

ors;

  foreach my $type (@types ? @types : (keys %types)) {
    push @SetErrors, {
      type => JSON::Typist::String->new($type),
      ($types{$type} ? (%{$types{$type}}) : ()),
    };
  }

  retur

tion::Generators::File;

use strict;
use warnings;

use JMAP::Validation::Generators::String;
use JSON::Typist;

sub generate {
  my $blobId = 1;

  my @files;

  foreach my $type (JMAP::Validation::G

each my $name (JMAP::Validation::Generators::String->generate(), undef) {
      foreach my $size (JSON::Typist::Number->new(int(rand(2**32))), undef) {
        push @files, {
          blobId => JMAP:

ion;
use JMAP::Validation::Generators::File;
use JMAP::Validation::Generators::String;
use JSON::PP;
use JSON::Typist;

sub generate {
  my ($type) = @_;

  my @avatars = (
    JMAP::Validation::Gener

Generators::Address::generate()],
    [],
  );

  my @Contacts;

  foreach my $isFlagged (JSON::PP::true, JSON::PP::false) {
    foreach my $avatar (@avatars) {
      foreach my $email (@{$ContactInfo

String->generate(),
                birthday    => JSON::Typist::String->new(fake_past_datetime('%Y-%m-%d')->()),
                anniversary => JSON::Typist::String->new(fake_past_datetime('%Y-%m-%d'

Validation::Generators::String;

use strict;
use warnings;

use Data::Fake::Text;
use JSON::PP;
use JSON::Typist;

sub generate {
  return JSON::Typist::String->new(join '', fake_words(4)->());
}

1;

nerators::ContactGroup;

use strict;
use warnings;

use JMAP::Validation::Generators::String;
use JSON::Typist;

sub generate {
  my (%args) = @_;

  my @contactIds
    = map { JMAP::Validation::Gener

gs;

use JSON::PP;
use JSON::Typist;
use JMAP::Validation::Generators::String;

sub true {
  return JSON::PP::true;
}

sub false {
  return JSON::PP::false;
}

sub negative_int {
  return JSON::Typist

eturn JSON::Typist::Number->new(0-(rand 2**64));
}

sub zero {
  return JSON::Typist::Number->new(0);
}

sub int {
  return JSON::Typist::Number->new(int(rand 2**64));
}

sub real {
  return JSON::Typ

rators::Address;

use strict;
use warnings;

use JMAP::Validation::Generators::String;
use JSON::PP;
use JSON::Typist;

sub generate {
  my @Addresses;

  foreach my $type (qw{home work billing postal

ring->generate(), undef) {
      foreach my $isDefault (JSON::PP::true, JSON::PP::false) {
        push @Addresses, {
          type      => JSON::Typist::String->new($type),
          label     => $l

tactInformation;

use strict;
use warnings;

use JMAP::Validation::Generators::String;
use JSON::PP;
use JSON::Typist;

my %types = (
  emails => [qw{
    personal
    work
    other
  }],
  phones =>

>generate(), undef) {
      foreach my $isDefault (JSON::PP::true, JSON::PP::false) {
        push @ContactInformation, {
          type      => JSON::Typist::String->new($type_value),
          label

package JMAP::Validation::Tests::Number;

use strict;
use warnings;

sub is_number {
  my ($value) = @_;

  return (ref($value) || '') eq 'JSON::Typist::Number';
}

1;

package JMAP::Validation::Checks::Boolean;

use Test2::Bundle::Extended;

our $is_boolean = validator(sub {
  my (%params) = @_;

  return (ref($params{got}) || '') eq 'JSON::PP::Boolean';
});

1;

:Array;

 # data types {{{

sub is_string {
  my ($value) = @_;

  return (ref($value) || '') eq 'JSON::Typist::String';
}

# }}}

# restrictions {{{

sub has_at_least_one_character {
  my ($value) = 

::Tests::SetError;
use JMAP::Validation::Tests::String;
use JSON::Typist;
use Test2::Bundle::Extended;

# record types {{{

my $typist = JSON::Typist->new();

my %ContactGroup_checks = (
  id => $JMAP

{{

our $is_string = validator(sub {
  my (%params) = @_;

  return (ref($params{got}) || '') eq 'JSON::Typist::String';
});

# }}}

# restrictions {{{

our $is_string_or_null = in_set($is_string, U()

::Number;
use Test2::Bundle::Extended;

use JSON::Typist;

our $is_number = validator(sub {
  my (%params) = @_;

  return (ref($params{got}) || '') eq 'JSON::Typist::Number';
});

our $is_number_or_n

 JMAP::Validation::Generators::ContactGroup;
use JMAP::Validation::Generators::String;
use JSON::PP;
use JSON::Typist;
use Test2::Bundle::Extended;
use Test::Deep qw{eq_deeply};

my (
  %ACCOUNT,
  %S

ators::real(),
        array         => [],
        object        => {},
        ok            => JSON::PP::null,
      }->{$test->{ifInState}},
      create => {
        true                => JMAP::

mit') {
    $request_args{accountId} = {
      supplied => $ACCOUNT{accountId},
      null     => JSON::PP::null,
    }->{$test->{accountId}};
  }

  my $contactGroups = $ACCOUNT{jmap}->request([["get