text:
NSString * const kGTLRBooksAcquireMethodFamilyShared     = @"FAMILY_SHARED";
NSString * const kGTLRBooksAcquireMethodPreordered       = @"PREORDERED";
NSString * const kGTLRBooksAcquireMethodPreviouslyRented = @"PREVIOUSLY_RENTED";
NSString * const kGTLRBooksAcquireMethodPublicDomain     = @"PUBLIC_DOMAIN";
NSString * const kGTLRBooksAcquireMethodPurchased        = @"PURCHASED";
NSString * const kGTLRBooksAcquireMethodRented           = @"RENTED";
NSString * const kGTLRBooksAcquireMethodSample           = @"SAMPLE";
NSString * const kGTLRBooksAcquireMethodUploaded         = @"UPLOADED";

// action
NSString * const kGTLRBooksActionBookmark = @"bookmark";
NSString * const kGTLRBooksActionChapter  = @"chapter";
NSString * const kGTLRBooksActionNextPage = @"next-page";
NSString * const kGTLRBooksActionPrevPage = @"prev-page";
NSString * const kGTLRBooksActionScroll   = @"scroll";
NSString * const kGTLRBooksActionSearch   = @"search";

// association
NSString * const kGTLRBooksAssociationEndOfSample    = @"end-of-sample";
NSString * const kGTLRBooksAssociationEndOfVolume    = @"end-of-volume";
NSString * const kGTLRBooksAssociationRelatedForPlay = @"related-for-play";

// download
NSString * const kGTLRBooksDownloadEpub = @"epub";

// features
NSString * const kGTLRBooksFeaturesRentals = @"RENTALS";

// filter
NSString * const kGTLRBooksFilterEbooks     = @"ebooks";
NSString * const kGTLRBooksFilterFreeEbooks = @"free-ebooks";
NSString * const kGTLRBooksFilterFull       = @"full";
NSString * const kGTLRBooksFilterPaidEbooks = @"paid-ebooks";
NSString * const kGTLRBooksFilterPartial    = @"partial";

// libraryRestrict
NSString * const kGTLRBooksLibraryRestrictMyLibrary  = @"my-library";
NSString * const kGTLRBooksLibraryRestrictNoRestrict = @"no-restrict";

// licenseTypes
NSString * const kGTLRBooksLicenseTypesBoth       = @"BOTH";
NSString * const kGTLRBooksLicenseTypesConcurrent = @"CONCURRENT";
NSString * const kGTLRBooksLicenseTypesDownload   = @"DOWNLOAD";

// maxAllowedMaturityRating
NSString * const kGTLRBooksMaxAllowedMaturityRatingMature    = @"mature";
NSString * const kGTLRBooksMaxAllowedMaturityRatingNotMature = @"not-mature";

// orderBy
NSString * const kGTLRBooksOrderByNewest    = @"newest";
NSString * const kGTLRBooksOrderByRelevance = @"relevance";

// printType
NSString * const kGTLRBooksPrintTypeAll       = @"all";
NSString * const kGTLRBooksPrintTypeBooks     = @"books";
NSString * const kGTLRBooksPrintTypeMagazines = @"magazines";

// processingState
NSString * const kGTLRBooksProcessingStateCompletedFailed  = @"COMPLETED_FAILED";
NSString * const kGTLRBooksProcessingStateCompletedSuccess = @"COMPLETED_SUCCESS";
NSString * const kGTLRBooksProcessingStateRunning          = @"RUNNING";

// projection
NSString * const kGTLRBooksProjectionFull = @"full";
NSString * const kGTLRBooksProjectionLite = @"lite";

// rating
NSString * const kGTLRBooksRatingHaveIt        = @"HAVE_IT";
NSString * const kGTLRBooksRatingNotInterested = @"NOT_INTERESTED";

// reason
NSString * const kGTLRBooksReasonIosPrex    = @"IOS_PREX";
NSString * const kGTLRBooksReasonIosSearch  = @"IOS_SEARCH";
NSString * const kGTLRBooksReasonOnboarding = @"ONBOARDING";

// ----------------------------------------------------------------------------
// Query Classes
//

@implementation GTLRBooksQuery

@dynamic fields;

@end

@implementation GTLRBooksQuery_BookshelvesGet

@dynamic shelf, source, userId;

+ (instancetype)queryWithUserId:(NSString *)userId
                          shelf:(NSString *)shelf {
  NSArray *pathParams = @[
    @"shelf", @"userId"
  ];
  NSString *pathURITemplate = @"users/{userId}/bookshelves/{shelf}";
  GTLRBooksQuery_BookshelvesGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.userId = userId;
  query.shelf = shelf;
  query.expectedObjectClass = [GTLRBooks_Bookshelf class];
  query.loggingName = @"books.bookshelves.get";
  return query;
}

@end

@implementation GTLRBooksQuery_BookshelvesList

@dynamic source, userId;

+ (instancetype)queryWithUserId:(NSString *)userId {
  NSArray *pathParams = @[ @"userId" ];
  NSString *pathURITemplate = @"users/{userId}/bookshelves";
  GTLRBooksQuery_BookshelvesList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.userId = userId;
  query.expectedObjectClass = [GTLRBooks_Bookshelves class];
  query.loggingName = @"books.bookshelves.list";
  return query;
}

@end

@implementation GTLRBooksQuery_BookshelvesVolumesList

@dynamic maxResults, shelf, showPreorders, source, startIndex, userId;

+ (instancetype)queryWithUserId:(NSString *)userId
                          shelf:(NSString *)shelf {
  NSArray *pathParams = @[
    @"shelf", @"userId"
  ];
  NSString *pathURITemplate = @"users/{userId}/bookshelves/{shelf}/volumes";
  GTLRBooksQuery_BookshelvesVolumesList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.userId = userId;
  query.shelf = shelf;
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.bookshelves.volumes.list";
  return query;
}

@end

@implementation GTLRBooksQuery_CloudloadingAddBook

@dynamic driveDocumentId, mimeType, name, uploadClientToken;

+ (NSDictionary<NSString *, NSString *> *)parameterNameMap {
  NSDictionary<NSString *, NSString *> *map = @{
    @"driveDocumentId" : @"drive_document_id",
    @"mimeType" : @"mime_type",
    @"uploadClientToken" : @"upload_client_token"
  };
  return map;
}

+ (instancetype)query {
  NSString *pathURITemplate = @"cloudloading/addBook";
  GTLRBooksQuery_CloudloadingAddBook *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_CloudloadingResource class];
  query.loggingName = @"books.cloudloading.addBook";
  return query;
}

@end

@implementation GTLRBooksQuery_CloudloadingDeleteBook

@dynamic volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId {
  NSString *pathURITemplate = @"cloudloading/deleteBook";
  GTLRBooksQuery_CloudloadingDeleteBook *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.volumeId = volumeId;
  query.loggingName = @"books.cloudloading.deleteBook";
  return query;
}

@end

@implementation GTLRBooksQuery_CloudloadingUpdateBook

+ (instancetype)queryWithObject:(GTLRBooks_CloudloadingResource *)object {
  if (object == nil) {
    GTLR_DEBUG_ASSERT(object != nil, @"Got a nil object");
    return nil;
  }
  NSString *pathURITemplate = @"cloudloading/updateBook";
  GTLRBooksQuery_CloudloadingUpdateBook *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.bodyObject = object;
  query.expectedObjectClass = [GTLRBooks_CloudloadingResource class];
  query.loggingName = @"books.cloudloading.updateBook";
  return query;
}

@end

@implementation GTLRBooksQuery_DictionaryListOfflineMetadata

@dynamic cpksver;

+ (instancetype)queryWithCpksver:(NSString *)cpksver {
  NSString *pathURITemplate = @"dictionary/listOfflineMetadata";
  GTLRBooksQuery_DictionaryListOfflineMetadata *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.cpksver = cpksver;
  query.expectedObjectClass = [GTLRBooks_Metadata class];
  query.loggingName = @"books.dictionary.listOfflineMetadata";
  return query;
}

@end

@implementation GTLRBooksQuery_LayersAnnotationDataGet

@dynamic allowWebDefinitions, annotationDataId, contentVersion, h, layerId,
         locale, scale, source, volumeId, w;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId
                          layerId:(NSString *)layerId
                 annotationDataId:(NSString *)annotationDataId
                   contentVersion:(NSString *)contentVersion {
  NSArray *pathParams = @[
    @"annotationDataId", @"layerId", @"volumeId"
  ];
  NSString *pathURITemplate = @"volumes/{volumeId}/layers/{layerId}/data/{annotationDataId}";
  GTLRBooksQuery_LayersAnnotationDataGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.layerId = layerId;
  query.annotationDataId = annotationDataId;
  query.contentVersion = contentVersion;
  query.expectedObjectClass = [GTLRBooks_Annotationdata class];
  query.loggingName = @"books.layers.annotationData.get";
  return query;
}

@end

@implementation GTLRBooksQuery_LayersAnnotationDataList

@dynamic annotationDataId, contentVersion, h, layerId, locale, maxResults,
         pageToken, scale, source, updatedMax, updatedMin, volumeId, w;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"annotationDataId" : [NSString class]
  };
  return map;
}

+ (instancetype)queryWithVolumeId:(NSString *)volumeId
                          layerId:(NSString *)layerId
                   contentVersion:(NSString *)contentVersion {
  NSArray *pathParams = @[
    @"layerId", @"volumeId"
  ];
  NSString *pathURITemplate = @"volumes/{volumeId}/layers/{layerId}/data";
  GTLRBooksQuery_LayersAnnotationDataList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.layerId = layerId;
  query.contentVersion = contentVersion;
  query.expectedObjectClass = [GTLRBooks_Annotationsdata class];
  query.loggingName = @"books.layers.annotationData.list";
  return query;
}

@end

@implementation GTLRBooksQuery_LayersGet

@dynamic contentVersion, source, summaryId, volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId
                        summaryId:(NSString *)summaryId {
  NSArray *pathParams = @[
    @"summaryId", @"volumeId"
  ];
  NSString *pathURITemplate = @"volumes/{volumeId}/layersummary/{summaryId}";
  GTLRBooksQuery_LayersGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.summaryId = summaryId;
  query.expectedObjectClass = [GTLRBooks_Layersummary class];
  query.loggingName = @"books.layers.get";
  return query;
}

@end

@implementation GTLRBooksQuery_LayersList

@dynamic contentVersion, maxResults, pageToken, source, volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId {
  NSArray *pathParams = @[ @"volumeId" ];
  NSString *pathURITemplate = @"volumes/{volumeId}/layersummary";
  GTLRBooksQuery_LayersList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.expectedObjectClass = [GTLRBooks_Layersummaries class];
  query.loggingName = @"books.layers.list";
  return query;
}

@end

@implementation GTLRBooksQuery_LayersVolumeAnnotationsGet

@dynamic annotationId, layerId, locale, source, volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId
                          layerId:(NSString *)layerId
                     annotationId:(NSString *)annotationId {
  NSArray *pathParams = @[
    @"annotationId", @"layerId", @"volumeId"
  ];
  NSString *pathURITemplate = @"volumes/{volumeId}/layers/{layerId}/annotations/{annotationId}";
  GTLRBooksQuery_LayersVolumeAnnotationsGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.layerId = layerId;
  query.annotationId = annotationId;
  query.expectedObjectClass = [GTLRBooks_Volumeannotation class];
  query.loggingName = @"books.layers.volumeAnnotations.get";
  return query;
}

@end

@implementation GTLRBooksQuery_LayersVolumeAnnotationsList

@dynamic contentVersion, endOffset, endPosition, layerId, locale, maxResults,
         pageToken, showDeleted, source, startOffset, startPosition, updatedMax,
         updatedMin, volumeAnnotationsVersion, volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId
                          layerId:(NSString *)layerId
                   contentVersion:(NSString *)contentVersion {
  NSArray *pathParams = @[
    @"layerId", @"volumeId"
  ];
  NSString *pathURITemplate = @"volumes/{volumeId}/layers/{layerId}";
  GTLRBooksQuery_LayersVolumeAnnotationsList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.layerId = layerId;
  query.contentVersion = contentVersion;
  query.expectedObjectClass = [GTLRBooks_Volumeannotations class];
  query.loggingName = @"books.layers.volumeAnnotations.list";
  return query;
}

@end

@implementation GTLRBooksQuery_MyconfigGetUserSettings

+ (instancetype)query {
  NSString *pathURITemplate = @"myconfig/getUserSettings";
  GTLRBooksQuery_MyconfigGetUserSettings *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Usersettings class];
  query.loggingName = @"books.myconfig.getUserSettings";
  return query;
}

@end

@implementation GTLRBooksQuery_MyconfigReleaseDownloadAccess

@dynamic cpksver, locale, source, volumeIds;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"volumeIds" : [NSString class]
  };
  return map;
}

+ (instancetype)queryWithVolumeIds:(NSArray<NSString *> *)volumeIds
                           cpksver:(NSString *)cpksver {
  NSString *pathURITemplate = @"myconfig/releaseDownloadAccess";
  GTLRBooksQuery_MyconfigReleaseDownloadAccess *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.volumeIds = volumeIds;
  query.cpksver = cpksver;
  query.expectedObjectClass = [GTLRBooks_DownloadAccesses class];
  query.loggingName = @"books.myconfig.releaseDownloadAccess";
  return query;
}

@end

@implementation GTLRBooksQuery_MyconfigRequestAccess

@dynamic cpksver, licenseTypes, locale, nonce, source, volumeId;

+ (instancetype)queryWithSource:(NSString *)source
                       volumeId:(NSString *)volumeId
                          nonce:(NSString *)nonce
                        cpksver:(NSString *)cpksver {
  NSString *pathURITemplate = @"myconfig/requestAccess";
  GTLRBooksQuery_MyconfigRequestAccess *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.source = source;
  query.volumeId = volumeId;
  query.nonce = nonce;
  query.cpksver = cpksver;
  query.expectedObjectClass = [GTLRBooks_RequestAccess class];
  query.loggingName = @"books.myconfig.requestAccess";
  return query;
}

@end

@implementation GTLRBooksQuery_MyconfigSyncVolumeLicenses

@dynamic cpksver, features, includeNonComicsSeries, locale, nonce,
         showPreorders, source, volumeIds;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"features" : [NSString class],
    @"volumeIds" : [NSString class]
  };
  return map;
}

+ (instancetype)queryWithSource:(NSString *)source
                          nonce:(NSString *)nonce
                        cpksver:(NSString *)cpksver {
  NSString *pathURITemplate = @"myconfig/syncVolumeLicenses";
  GTLRBooksQuery_MyconfigSyncVolumeLicenses *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.source = source;
  query.nonce = nonce;
  query.cpksver = cpksver;
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.myconfig.syncVolumeLicenses";
  return query;
}

@end

@implementation GTLRBooksQuery_MyconfigUpdateUserSettings

+ (instancetype)queryWithObject:(GTLRBooks_Usersettings *)object {
  if (object == nil) {
    GTLR_DEBUG_ASSERT(object != nil, @"Got a nil object");
    return nil;
  }
  NSString *pathURITemplate = @"myconfig/updateUserSettings";
  GTLRBooksQuery_MyconfigUpdateUserSettings *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.bodyObject = object;
  query.expectedObjectClass = [GTLRBooks_Usersettings class];
  query.loggingName = @"books.myconfig.updateUserSettings";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryAnnotationsDelete

@dynamic annotationId, source;

+ (instancetype)queryWithAnnotationId:(NSString *)annotationId {
  NSArray *pathParams = @[ @"annotationId" ];
  NSString *pathURITemplate = @"mylibrary/annotations/{annotationId}";
  GTLRBooksQuery_MylibraryAnnotationsDelete *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"DELETE"
                       pathParameterNames:pathParams];
  query.annotationId = annotationId;
  query.loggingName = @"books.mylibrary.annotations.delete";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryAnnotationsInsert

@dynamic country, showOnlySummaryInResponse, source;

+ (instancetype)queryWithObject:(GTLRBooks_Annotation *)object {
  if (object == nil) {
    GTLR_DEBUG_ASSERT(object != nil, @"Got a nil object");
    return nil;
  }
  NSString *pathURITemplate = @"mylibrary/annotations";
  GTLRBooksQuery_MylibraryAnnotationsInsert *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.bodyObject = object;
  query.expectedObjectClass = [GTLRBooks_Annotation class];
  query.loggingName = @"books.mylibrary.annotations.insert";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryAnnotationsList

@dynamic contentVersion, layerId, layerIds, maxResults, pageToken, showDeleted,
         source, updatedMax, updatedMin, volumeId;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"layerIds" : [NSString class]
  };
  return map;
}

+ (instancetype)query {
  NSString *pathURITemplate = @"mylibrary/annotations";
  GTLRBooksQuery_MylibraryAnnotationsList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Annotations class];
  query.loggingName = @"books.mylibrary.annotations.list";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryAnnotationsSummary

@dynamic layerIds, volumeId;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"layerIds" : [NSString class]
  };
  return map;
}

+ (instancetype)queryWithLayerIds:(NSArray<NSString *> *)layerIds
                         volumeId:(NSString *)volumeId {
  NSString *pathURITemplate = @"mylibrary/annotations/summary";
  GTLRBooksQuery_MylibraryAnnotationsSummary *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.layerIds = layerIds;
  query.volumeId = volumeId;
  query.expectedObjectClass = [GTLRBooks_AnnotationsSummary class];
  query.loggingName = @"books.mylibrary.annotations.summary";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryAnnotationsUpdate

@dynamic annotationId, source;

+ (instancetype)queryWithObject:(GTLRBooks_Annotation *)object
                   annotationId:(NSString *)annotationId {
  if (object == nil) {
    GTLR_DEBUG_ASSERT(object != nil, @"Got a nil object");
    return nil;
  }
  NSArray *pathParams = @[ @"annotationId" ];
  NSString *pathURITemplate = @"mylibrary/annotations/{annotationId}";
  GTLRBooksQuery_MylibraryAnnotationsUpdate *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"PUT"
                       pathParameterNames:pathParams];
  query.bodyObject = object;
  query.annotationId = annotationId;
  query.expectedObjectClass = [GTLRBooks_Annotation class];
  query.loggingName = @"books.mylibrary.annotations.update";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesAddVolume

@dynamic reason, shelf, source, volumeId;

+ (instancetype)queryWithShelf:(NSString *)shelf
                      volumeId:(NSString *)volumeId {
  NSArray *pathParams = @[ @"shelf" ];
  NSString *pathURITemplate = @"mylibrary/bookshelves/{shelf}/addVolume";
  GTLRBooksQuery_MylibraryBookshelvesAddVolume *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:pathParams];
  query.shelf = shelf;
  query.volumeId = volumeId;
  query.loggingName = @"books.mylibrary.bookshelves.addVolume";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesClearVolumes

@dynamic shelf, source;

+ (instancetype)queryWithShelf:(NSString *)shelf {
  NSArray *pathParams = @[ @"shelf" ];
  NSString *pathURITemplate = @"mylibrary/bookshelves/{shelf}/clearVolumes";
  GTLRBooksQuery_MylibraryBookshelvesClearVolumes *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:pathParams];
  query.shelf = shelf;
  query.loggingName = @"books.mylibrary.bookshelves.clearVolumes";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesGet

@dynamic shelf, source;

+ (instancetype)queryWithShelf:(NSString *)shelf {
  NSArray *pathParams = @[ @"shelf" ];
  NSString *pathURITemplate = @"mylibrary/bookshelves/{shelf}";
  GTLRBooksQuery_MylibraryBookshelvesGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.shelf = shelf;
  query.expectedObjectClass = [GTLRBooks_Bookshelf class];
  query.loggingName = @"books.mylibrary.bookshelves.get";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesList

@dynamic source;

+ (instancetype)query {
  NSString *pathURITemplate = @"mylibrary/bookshelves";
  GTLRBooksQuery_MylibraryBookshelvesList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Bookshelves class];
  query.loggingName = @"books.mylibrary.bookshelves.list";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesMoveVolume

@dynamic shelf, source, volumeId, volumePosition;

+ (instancetype)queryWithShelf:(NSString *)shelf
                      volumeId:(NSString *)volumeId
                volumePosition:(NSInteger)volumePosition {
  NSArray *pathParams = @[ @"shelf" ];
  NSString *pathURITemplate = @"mylibrary/bookshelves/{shelf}/moveVolume";
  GTLRBooksQuery_MylibraryBookshelvesMoveVolume *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:pathParams];
  query.shelf = shelf;
  query.volumeId = volumeId;
  query.volumePosition = volumePosition;
  query.loggingName = @"books.mylibrary.bookshelves.moveVolume";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesRemoveVolume

@dynamic reason, shelf, source, volumeId;

+ (instancetype)queryWithShelf:(NSString *)shelf
                      volumeId:(NSString *)volumeId {
  NSArray *pathParams = @[ @"shelf" ];
  NSString *pathURITemplate = @"mylibrary/bookshelves/{shelf}/removeVolume";
  GTLRBooksQuery_MylibraryBookshelvesRemoveVolume *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:pathParams];
  query.shelf = shelf;
  query.volumeId = volumeId;
  query.loggingName = @"books.mylibrary.bookshelves.removeVolume";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryBookshelvesVolumesList

@dynamic country, maxResults, projection, q, shelf, showPreorders, source,
         startIndex;

+ (instancetype)queryWithShelf:(NSString *)shelf {
  NSArray *pathParams = @[ @"shelf" ];
  NSString *pathURITemplate = @"mylibrary/bookshelves/{shelf}/volumes";
  GTLRBooksQuery_MylibraryBookshelvesVolumesList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.shelf = shelf;
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.mylibrary.bookshelves.volumes.list";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryReadingpositionsGet

@dynamic contentVersion, source, volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId {
  NSArray *pathParams = @[ @"volumeId" ];
  NSString *pathURITemplate = @"mylibrary/readingpositions/{volumeId}";
  GTLRBooksQuery_MylibraryReadingpositionsGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.expectedObjectClass = [GTLRBooks_ReadingPosition class];
  query.loggingName = @"books.mylibrary.readingpositions.get";
  return query;
}

@end

@implementation GTLRBooksQuery_MylibraryReadingpositionsSetPosition

@dynamic action, contentVersion, deviceCookie, position, source, timestamp,
         volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId
                        timestamp:(NSString *)timestamp
                         position:(NSString *)position {
  NSArray *pathParams = @[ @"volumeId" ];
  NSString *pathURITemplate = @"mylibrary/readingpositions/{volumeId}/setPosition";
  GTLRBooksQuery_MylibraryReadingpositionsSetPosition *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.timestamp = timestamp;
  query.position = position;
  query.loggingName = @"books.mylibrary.readingpositions.setPosition";
  return query;
}

@end

@implementation GTLRBooksQuery_NotificationGet

@dynamic locale, notificationId, source;

+ (NSDictionary<NSString *, NSString *> *)parameterNameMap {
  return @{ @"notificationId" : @"notification_id" };
}

+ (instancetype)queryWithNotificationId:(NSString *)notificationId {
  NSString *pathURITemplate = @"notification/get";
  GTLRBooksQuery_NotificationGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.notificationId = notificationId;
  query.expectedObjectClass = [GTLRBooks_Notification class];
  query.loggingName = @"books.notification.get";
  return query;
}

@end

@implementation GTLRBooksQuery_OnboardingListCategories

@dynamic locale;

+ (instancetype)query {
  NSString *pathURITemplate = @"onboarding/listCategories";
  GTLRBooksQuery_OnboardingListCategories *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Category class];
  query.loggingName = @"books.onboarding.listCategories";
  return query;
}

@end

@implementation GTLRBooksQuery_OnboardingListCategoryVolumes

@dynamic categoryId, locale, maxAllowedMaturityRating, pageSize, pageToken;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"categoryId" : [NSString class]
  };
  return map;
}

+ (instancetype)query {
  NSString *pathURITemplate = @"onboarding/listCategoryVolumes";
  GTLRBooksQuery_OnboardingListCategoryVolumes *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Volume2 class];
  query.loggingName = @"books.onboarding.listCategoryVolumes";
  return query;
}

@end

@implementation GTLRBooksQuery_PersonalizedstreamGet

@dynamic locale, maxAllowedMaturityRating, source;

+ (instancetype)query {
  NSString *pathURITemplate = @"personalizedstream/get";
  GTLRBooksQuery_PersonalizedstreamGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Discoveryclusters class];
  query.loggingName = @"books.personalizedstream.get";
  return query;
}

@end

@implementation GTLRBooksQuery_PromoofferAccept

@dynamic androidId, device, manufacturer, model, offerId, product, serial,
         volumeId;

+ (instancetype)query {
  NSString *pathURITemplate = @"promooffer/accept";
  GTLRBooksQuery_PromoofferAccept *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.loggingName = @"books.promooffer.accept";
  return query;
}

@end

@implementation GTLRBooksQuery_PromoofferDismiss

@dynamic androidId, device, manufacturer, model, offerId, product, serial;

+ (instancetype)query {
  NSString *pathURITemplate = @"promooffer/dismiss";
  GTLRBooksQuery_PromoofferDismiss *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.loggingName = @"books.promooffer.dismiss";
  return query;
}

@end

@implementation GTLRBooksQuery_PromoofferGet

@dynamic androidId, device, manufacturer, model, product, serial;

+ (instancetype)query {
  NSString *pathURITemplate = @"promooffer/get";
  GTLRBooksQuery_PromoofferGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Offers class];
  query.loggingName = @"books.promooffer.get";
  return query;
}

@end

@implementation GTLRBooksQuery_SeriesGet

@dynamic seriesId;

+ (NSDictionary<NSString *, NSString *> *)parameterNameMap {
  return @{ @"seriesId" : @"series_id" };
}

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"series_id" : [NSString class]
  };
  return map;
}

+ (instancetype)queryWithSeriesId:(NSArray<NSString *> *)seriesId {
  NSString *pathURITemplate = @"series/get";
  GTLRBooksQuery_SeriesGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.seriesId = seriesId;
  query.expectedObjectClass = [GTLRBooks_Series class];
  query.loggingName = @"books.series.get";
  return query;
}

@end

@implementation GTLRBooksQuery_SeriesMembershipGet

@dynamic pageSize, pageToken, seriesId;

+ (NSDictionary<NSString *, NSString *> *)parameterNameMap {
  NSDictionary<NSString *, NSString *> *map = @{
    @"pageSize" : @"page_size",
    @"pageToken" : @"page_token",
    @"seriesId" : @"series_id"
  };
  return map;
}

+ (instancetype)queryWithSeriesId:(NSString *)seriesId {
  NSString *pathURITemplate = @"series/membership/get";
  GTLRBooksQuery_SeriesMembershipGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.seriesId = seriesId;
  query.expectedObjectClass = [GTLRBooks_Seriesmembership class];
  query.loggingName = @"books.series.membership.get";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesAssociatedList

@dynamic association, locale, maxAllowedMaturityRating, source, volumeId;

+ (instancetype)queryWithVolumeId:(NSString *)volumeId {
  NSArray *pathParams = @[ @"volumeId" ];
  NSString *pathURITemplate = @"volumes/{volumeId}/associated";
  GTLRBooksQuery_VolumesAssociatedList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.volumes.associated.list";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesGet

@dynamic country, includeNonComicsSeries, partner, projection, source,
         userLibraryConsistentRead, volumeId;

+ (NSDictionary<NSString *, NSString *> *)parameterNameMap {
  return @{ @"userLibraryConsistentRead" : @"user_library_consistent_read" };
}

+ (instancetype)queryWithVolumeId:(NSString *)volumeId {
  NSArray *pathParams = @[ @"volumeId" ];
  NSString *pathURITemplate = @"volumes/{volumeId}";
  GTLRBooksQuery_VolumesGet *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:pathParams];
  query.volumeId = volumeId;
  query.expectedObjectClass = [GTLRBooks_Volume class];
  query.loggingName = @"books.volumes.get";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesList

@dynamic download, filter, langRestrict, libraryRestrict, maxResults, orderBy,
         partner, printType, projection, q, showPreorders, source, startIndex;

+ (instancetype)queryWithQ:(NSString *)q {
  NSString *pathURITemplate = @"volumes";
  GTLRBooksQuery_VolumesList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.q = q;
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.volumes.list";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesMybooksList

@dynamic acquireMethod, country, locale, maxResults, processingState, source,
         startIndex;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"acquireMethod" : [NSString class],
    @"processingState" : [NSString class]
  };
  return map;
}

+ (instancetype)query {
  NSString *pathURITemplate = @"volumes/mybooks";
  GTLRBooksQuery_VolumesMybooksList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.volumes.mybooks.list";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesRecommendedList

@dynamic locale, maxAllowedMaturityRating, source;

+ (instancetype)query {
  NSString *pathURITemplate = @"volumes/recommended";
  GTLRBooksQuery_VolumesRecommendedList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.volumes.recommended.list";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesRecommendedRate

@dynamic locale, rating, source, volumeId;

+ (instancetype)queryWithRating:(NSString *)rating
                       volumeId:(NSString *)volumeId {
  NSString *pathURITemplate = @"volumes/recommended/rate";
  GTLRBooksQuery_VolumesRecommendedRate *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:@"POST"
                       pathParameterNames:nil];
  query.rating = rating;
  query.volumeId = volumeId;
  query.expectedObjectClass = [GTLRBooks_VolumesRecommendedRateResponse class];
  query.loggingName = @"books.volumes.recommended.rate";
  return query;
}

@end

@implementation GTLRBooksQuery_VolumesUseruploadedList

@dynamic locale, maxResults, processingState, source, startIndex, volumeId;

+ (NSDictionary<NSString *, Class> *)arrayPropertyToClassMap {
  NSDictionary<NSString *, Class> *map = @{
    @"processingState" : [NSString class],
    @"volumeId" : [NSString class]
  };
  return map;
}

+ (instancetype)query {
  NSString *pathURITemplate = @"volumes/useruploaded";
  GTLRBooksQuery_VolumesUseruploadedList *query =
    [[self alloc] initWithPathURITemplate:pathURITemplate
                               HTTPMethod:nil
                       pathParameterNames:nil];
  query.expectedObjectClass = [GTLRBooks_Volumes class];
  query.loggingName = @"books.volumes.useruploaded.list";
  return query;
}

@end


text:
import { JsonPointer } from './interface';
export declare function buildJsonPointer(fragments: string[]): JsonPointer;
export declare function joinJsonPointer(root: JsonPointer, ...others: string[]): JsonPointer;
export declare function parseJsonPointer(pointer: JsonPointer): string[];

redpajama_set_name: RedPajamaGithub


text:
help:
	@echo " make prepare       prepares the system for building"
	@echo ""
	@echo " make build         build from sources, but no daemon installation"
	@echo ""
	@echo " make clean         clear build artifacts"
	@echo ""
	@echo " make purge         Removes everything from this on the system."
	@echo ""
	@echo " make install       install as daemon"
	@echo ""
	@echo " make uninstall     uninstall daemon"
	@echo ""
	@echo " make update        update from the sources and install as daemon"
	@echo ""
	@echo ""
	@echo " make graceful      graceful apache restart"
	@echo ""
	@echo " make stop          stops apache"
	@echo ""
	@echo " make start         starts apache"
	@echo ""
	@echo " make checksyntax   apache config syntax check"
	@echo ""

prepare:
	@./preparesystem.sh

build:
	@echo "Build"
	@./build_apache.sh

clean:
	@./clean.sh

purge:
	@./purge.sh

install:
	@echo "Install as daemon"
	@./install_as_daemon.sh

uninstall:
	@echo "Uninstall daemon"
	@./uninstall_daemon.sh

update:
	@./update.sh

graceful:
	@sudo /opt/apache2/bin/httpd -k graceful

stop:
	@sudo /opt/apache2/bin/httpd -k stop

start:
	@sudo /opt/apache2/bin/httpd -k start

checksyntax:
	@sudo /opt/apache2/bin/httpd -S


text:
<!DOCTYPE html>

    <meta http-equiv="refresh" content="0;URL=type.U405.html">

Redirecting to type.U405.html...


text:
require "red_alert/sensor"
require "red_alert/version"

module RedAlert
  def self.run
    require 'daemons'
    Daemons.run_proc('red_alert', { ARGV: ['run'] }) do
      loop { Sensor.scan! }
    end
  end
end


text:
namespace SamplePatterns.Factory.Household
{
    public interface IMachine
    {
        string Name { get; }

        /// <summary>
        /// Turns the machine on.
        /// </summary>
        string TurnOn();

        /// <summary>
        /// Turns the machine off.
        /// </summary>
        string TurnOff();
    }
}


text:
package stream

import (
	"bytes"
	"encoding/json"
	"fmt"
	"testing"

	"kythe.io/kythe/go/platform/delimited"
	"kythe.io/kythe/go/test/testutil"

	spb "kythe.io/kythe/proto/storage_proto"
)

func TestReader(t *testing.T) {
	r := testBuffer(testEntries)

	var i int
	if err := NewReader(r)(func(e *spb.Entry) error {
		if err := testutil.DeepEqual(testEntries[i], e); err != nil {
			t.Errorf("testEntries[%d]: %v", i, err)
		}
		i++
		return nil
	}); err != nil {
		t.Fatal(err)
	}

	if i != len(testEntries) {
		t.Fatal("Missing %d entries", len(testEntries)-i)
	}
}

func TestJSONReader(t *testing.T) {
	r := testJSONBuffer(testEntries)

	var i int
	if err := NewJSONReader(r)(func(e *spb.Entry) error {
		if err := testutil.DeepEqual(testEntries[i], e); err != nil {
			t.Errorf("testEntries[%d]: %v", i, err)
		}
		i++
		return nil
	}); err != nil {
		t.Fatal(err)
	}

	if i != len(testEntries) {
		t.Fatal("Missing %d entries", len(testEntries)-i)
	}
}

func BenchmarkReader(b *testing.B) {
	buf := testBuffer(genEntries(b.N))
	b.ResetTimer()
	if err := NewReader(buf)(func(e *spb.Entry) error {
		return nil
	}); err != nil {
		b.Fatal(err)
	}
}

func BenchmarkJSONReader(b *testing.B) {
	buf := testJSONBuffer(genEntries(b.N))
	b.ResetTimer()
	if err := NewJSONReader(buf)(func(e *spb.Entry) error {
		return nil
	}); err != nil {
		b.Fatal(err)
	}
}

func BenchmarkReaderChannel(b *testing.B) {
	buf := testBuffer(genEntries(b.N))
	b.ResetTimer()
	for range ReadEntries(buf) {
	}
}

func BenchmarkJSONReaderChannel(b *testing.B) {
	buf := testJSONBuffer(genEntries(b.N))
	b.ResetTimer()
	for range ReadJSONEntries(buf) {
	}
}

func testBuffer(entries []*spb.Entry) *bytes.Buffer {
	buf := bytes.NewBuffer(nil)
	wr := delimited.NewWriter(buf)
	for _, e := range entries {
		if err := wr.PutProto(e); err != nil {
			panic(err)
		}
	}
	return buf
}

func testJSONBuffer(entries []*spb.Entry) *bytes.Buffer {
	buf := bytes.NewBuffer(nil)
	wr := json.NewEncoder(buf)
	for _, e := range entries {
		if err := wr.Encode(e); err != nil {
			panic(err)
		}
	}
	return buf
}

var testEntries = []*spb.Entry{
	fact("node0", "kind", "test"),
	edge("node0", "edge", "node1"),
	fact("node1", "kind", "anotherTest"),
	fact("blah", "blah", "eh"),
}

func genEntries(n int) []*spb.Entry {
	entries := make([]*spb.Entry, n)
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			entries[i] = fact(fmt.Sprintf("node%d", i), "kind", "test")
		} else {
			entries[i] = edge(fmt.Sprintf("node%d", i-1), "edgeKind", fmt.Sprintf("node%d", i+1))
		}
	}
	return entries
}

func fact(signature, factName, factValue string) *spb.Entry {
	return &spb.Entry{
		Source:    &spb.VName{Signature: signature},
		FactName:  factName,
		FactValue: []byte(factValue),
	}
}

func edge(signature, edgeKind, targetSig string) *spb.Entry {
	return &spb.Entry{
		Source:   &spb.VName{Signature: signature},
		EdgeKind: edgeKind,
		Target:   &spb.VName{Signature: targetSig},
		FactName: "/",
	}
}