text:
module.exports = {
  format: 'query',
  apiVersion: '2013-06-15',
  endpointPrefix: 'elasticache',
  resultWrapped: true,
  serviceFullName: 'Amazon ElastiCache',
  signatureVersion: 'v2',
  timestampFormat: 'iso8601',
  operations: {
    authorizeCacheSecurityGroupIngress: {
      name: 'AuthorizeCacheSecurityGroupIngress',
      input: {
        type: 'structure',
        members: {
          CacheSecurityGroupName: {
            required: true
          },
          EC2SecurityGroupName: {
            required: true
          },
          EC2SecurityGroupOwnerId: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheSecurityGroup: {
            type: 'structure',
            members: {
              OwnerId: {
              },
              CacheSecurityGroupName: {
              },
              Description: {
              },
              EC2SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    Status: {
                    },
                    EC2SecurityGroupName: {
                    },
                    EC2SecurityGroupOwnerId: {
                    }
                  },
                  name: 'EC2SecurityGroup'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    createCacheCluster: {
      name: 'CreateCacheCluster',
      input: {
        type: 'structure',
        members: {
          CacheClusterId: {
            required: true
          },
          ReplicationGroupId: {
          },
          NumCacheNodes: {
            type: 'integer',
            required: true
          },
          CacheNodeType: {
            required: true
          },
          Engine: {
            required: true
          },
          EngineVersion: {
          },
          CacheParameterGroupName: {
          },
          CacheSubnetGroupName: {
          },
          CacheSecurityGroupNames: {
            type: 'list',
            members: {
              name: 'CacheSecurityGroupName'
            }
          },
          SecurityGroupIds: {
            type: 'list',
            members: {
              name: 'SecurityGroupId'
            }
          },
          SnapshotArns: {
            type: 'list',
            members: {
              name: 'SnapshotArn'
            }
          },
          PreferredAvailabilityZone: {
          },
          PreferredMaintenanceWindow: {
          },
          Port: {
            type: 'integer'
          },
          NotificationTopicArn: {
          },
          AutoMinorVersionUpgrade: {
            type: 'boolean'
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheCluster: {
            type: 'structure',
            members: {
              CacheClusterId: {
              },
              ConfigurationEndpoint: {
                type: 'structure',
                members: {
                  Address: {
                  },
                  Port: {
                    type: 'integer'
                  }
                }
              },
              ClientDownloadLandingPage: {
              },
              CacheNodeType: {
              },
              Engine: {
              },
              EngineVersion: {
              },
              CacheClusterStatus: {
              },
              NumCacheNodes: {
                type: 'integer'
              },
              PreferredAvailabilityZone: {
              },
              CacheClusterCreateTime: {
                type: 'timestamp'
              },
              PreferredMaintenanceWindow: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  NumCacheNodes: {
                    type: 'integer'
                  },
                  CacheNodeIdsToRemove: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  },
                  EngineVersion: {
                  }
                }
              },
              NotificationConfiguration: {
                type: 'structure',
                members: {
                  TopicArn: {
                  },
                  TopicStatus: {
                  }
                }
              },
              CacheSecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheSecurityGroupName: {
                    },
                    Status: {
                    }
                  },
                  name: 'CacheSecurityGroup'
                }
              },
              CacheParameterGroup: {
                type: 'structure',
                members: {
                  CacheParameterGroupName: {
                  },
                  ParameterApplyStatus: {
                  },
                  CacheNodeIdsToReboot: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  }
                }
              },
              CacheSubnetGroupName: {
              },
              CacheNodes: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheNodeId: {
                    },
                    CacheNodeStatus: {
                    },
                    CacheNodeCreateTime: {
                      type: 'timestamp'
                    },
                    Endpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    ParameterGroupStatus: {
                    },
                    SourceCacheNodeId: {
                    }
                  },
                  name: 'CacheNode'
                }
              },
              AutoMinorVersionUpgrade: {
                type: 'boolean'
              },
              SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    SecurityGroupId: {
                    },
                    Status: {
                    }
                  }
                }
              },
              ReplicationGroupId: {
              }
            },
            wrapper: true
          }
        }
      }
    },
    createCacheParameterGroup: {
      name: 'CreateCacheParameterGroup',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
            required: true
          },
          CacheParameterGroupFamily: {
            required: true
          },
          Description: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheParameterGroup: {
            type: 'structure',
            members: {
              CacheParameterGroupName: {
              },
              CacheParameterGroupFamily: {
              },
              Description: {
              }
            },
            wrapper: true
          }
        }
      }
    },
    createCacheSecurityGroup: {
      name: 'CreateCacheSecurityGroup',
      input: {
        type: 'structure',
        members: {
          CacheSecurityGroupName: {
            required: true
          },
          Description: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheSecurityGroup: {
            type: 'structure',
            members: {
              OwnerId: {
              },
              CacheSecurityGroupName: {
              },
              Description: {
              },
              EC2SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    Status: {
                    },
                    EC2SecurityGroupName: {
                    },
                    EC2SecurityGroupOwnerId: {
                    }
                  },
                  name: 'EC2SecurityGroup'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    createCacheSubnetGroup: {
      name: 'CreateCacheSubnetGroup',
      input: {
        type: 'structure',
        members: {
          CacheSubnetGroupName: {
            required: true
          },
          CacheSubnetGroupDescription: {
            required: true
          },
          SubnetIds: {
            type: 'list',
            members: {
              name: 'SubnetIdentifier'
            },
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheSubnetGroup: {
            type: 'structure',
            members: {
              CacheSubnetGroupName: {
              },
              CacheSubnetGroupDescription: {
              },
              VpcId: {
              },
              Subnets: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    SubnetIdentifier: {
                    },
                    SubnetAvailabilityZone: {
                      type: 'structure',
                      members: {
                        Name: {
                        }
                      },
                      wrapper: true
                    }
                  },
                  name: 'Subnet'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    createReplicationGroup: {
      name: 'CreateReplicationGroup',
      input: {
        type: 'structure',
        members: {
          ReplicationGroupId: {
            required: true
          },
          PrimaryClusterId: {
            required: true
          },
          ReplicationGroupDescription: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          ReplicationGroup: {
            type: 'structure',
            members: {
              ReplicationGroupId: {
              },
              Description: {
              },
              Status: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  PrimaryClusterId: {
                  }
                }
              },
              MemberClusters: {
                type: 'list',
                members: {
                  name: 'ClusterId'
                }
              },
              NodeGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    NodeGroupId: {
                    },
                    Status: {
                    },
                    PrimaryEndpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    NodeGroupMembers: {
                      type: 'list',
                      members: {
                        type: 'structure',
                        members: {
                          CacheClusterId: {
                          },
                          CacheNodeId: {
                          },
                          ReadEndpoint: {
                            type: 'structure',
                            members: {
                              Address: {
                              },
                              Port: {
                                type: 'integer'
                              }
                            }
                          },
                          PreferredAvailabilityZone: {
                          },
                          CurrentRole: {
                          }
                        },
                        name: 'NodeGroupMember'
                      }
                    }
                  },
                  name: 'NodeGroup'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    deleteCacheCluster: {
      name: 'DeleteCacheCluster',
      input: {
        type: 'structure',
        members: {
          CacheClusterId: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheCluster: {
            type: 'structure',
            members: {
              CacheClusterId: {
              },
              ConfigurationEndpoint: {
                type: 'structure',
                members: {
                  Address: {
                  },
                  Port: {
                    type: 'integer'
                  }
                }
              },
              ClientDownloadLandingPage: {
              },
              CacheNodeType: {
              },
              Engine: {
              },
              EngineVersion: {
              },
              CacheClusterStatus: {
              },
              NumCacheNodes: {
                type: 'integer'
              },
              PreferredAvailabilityZone: {
              },
              CacheClusterCreateTime: {
                type: 'timestamp'
              },
              PreferredMaintenanceWindow: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  NumCacheNodes: {
                    type: 'integer'
                  },
                  CacheNodeIdsToRemove: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  },
                  EngineVersion: {
                  }
                }
              },
              NotificationConfiguration: {
                type: 'structure',
                members: {
                  TopicArn: {
                  },
                  TopicStatus: {
                  }
                }
              },
              CacheSecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheSecurityGroupName: {
                    },
                    Status: {
                    }
                  },
                  name: 'CacheSecurityGroup'
                }
              },
              CacheParameterGroup: {
                type: 'structure',
                members: {
                  CacheParameterGroupName: {
                  },
                  ParameterApplyStatus: {
                  },
                  CacheNodeIdsToReboot: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  }
                }
              },
              CacheSubnetGroupName: {
              },
              CacheNodes: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheNodeId: {
                    },
                    CacheNodeStatus: {
                    },
                    CacheNodeCreateTime: {
                      type: 'timestamp'
                    },
                    Endpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    ParameterGroupStatus: {
                    },
                    SourceCacheNodeId: {
                    }
                  },
                  name: 'CacheNode'
                }
              },
              AutoMinorVersionUpgrade: {
                type: 'boolean'
              },
              SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    SecurityGroupId: {
                    },
                    Status: {
                    }
                  }
                }
              },
              ReplicationGroupId: {
              }
            },
            wrapper: true
          }
        }
      }
    },
    deleteCacheParameterGroup: {
      name: 'DeleteCacheParameterGroup',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
        }
      }
    },
    deleteCacheSecurityGroup: {
      name: 'DeleteCacheSecurityGroup',
      input: {
        type: 'structure',
        members: {
          CacheSecurityGroupName: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
        }
      }
    },
    deleteCacheSubnetGroup: {
      name: 'DeleteCacheSubnetGroup',
      input: {
        type: 'structure',
        members: {
          CacheSubnetGroupName: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
        }
      }
    },
    deleteReplicationGroup: {
      name: 'DeleteReplicationGroup',
      input: {
        type: 'structure',
        members: {
          ReplicationGroupId: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          ReplicationGroup: {
            type: 'structure',
            members: {
              ReplicationGroupId: {
              },
              Description: {
              },
              Status: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  PrimaryClusterId: {
                  }
                }
              },
              MemberClusters: {
                type: 'list',
                members: {
                  name: 'ClusterId'
                }
              },
              NodeGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    NodeGroupId: {
                    },
                    Status: {
                    },
                    PrimaryEndpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    NodeGroupMembers: {
                      type: 'list',
                      members: {
                        type: 'structure',
                        members: {
                          CacheClusterId: {
                          },
                          CacheNodeId: {
                          },
                          ReadEndpoint: {
                            type: 'structure',
                            members: {
                              Address: {
                              },
                              Port: {
                                type: 'integer'
                              }
                            }
                          },
                          PreferredAvailabilityZone: {
                          },
                          CurrentRole: {
                          }
                        },
                        name: 'NodeGroupMember'
                      }
                    }
                  },
                  name: 'NodeGroup'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    describeCacheClusters: {
      name: 'DescribeCacheClusters',
      input: {
        type: 'structure',
        members: {
          CacheClusterId: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          },
          ShowCacheNodeInfo: {
            type: 'boolean'
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          CacheClusters: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                CacheClusterId: {
                },
                ConfigurationEndpoint: {
                  type: 'structure',
                  members: {
                    Address: {
                    },
                    Port: {
                      type: 'integer'
                    }
                  }
                },
                ClientDownloadLandingPage: {
                },
                CacheNodeType: {
                },
                Engine: {
                },
                EngineVersion: {
                },
                CacheClusterStatus: {
                },
                NumCacheNodes: {
                  type: 'integer'
                },
                PreferredAvailabilityZone: {
                },
                CacheClusterCreateTime: {
                  type: 'timestamp'
                },
                PreferredMaintenanceWindow: {
                },
                PendingModifiedValues: {
                  type: 'structure',
                  members: {
                    NumCacheNodes: {
                      type: 'integer'
                    },
                    CacheNodeIdsToRemove: {
                      type: 'list',
                      members: {
                        name: 'CacheNodeId'
                      }
                    },
                    EngineVersion: {
                    }
                  }
                },
                NotificationConfiguration: {
                  type: 'structure',
                  members: {
                    TopicArn: {
                    },
                    TopicStatus: {
                    }
                  }
                },
                CacheSecurityGroups: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      CacheSecurityGroupName: {
                      },
                      Status: {
                      }
                    },
                    name: 'CacheSecurityGroup'
                  }
                },
                CacheParameterGroup: {
                  type: 'structure',
                  members: {
                    CacheParameterGroupName: {
                    },
                    ParameterApplyStatus: {
                    },
                    CacheNodeIdsToReboot: {
                      type: 'list',
                      members: {
                        name: 'CacheNodeId'
                      }
                    }
                  }
                },
                CacheSubnetGroupName: {
                },
                CacheNodes: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      CacheNodeId: {
                      },
                      CacheNodeStatus: {
                      },
                      CacheNodeCreateTime: {
                        type: 'timestamp'
                      },
                      Endpoint: {
                        type: 'structure',
                        members: {
                          Address: {
                          },
                          Port: {
                            type: 'integer'
                          }
                        }
                      },
                      ParameterGroupStatus: {
                      },
                      SourceCacheNodeId: {
                      }
                    },
                    name: 'CacheNode'
                  }
                },
                AutoMinorVersionUpgrade: {
                  type: 'boolean'
                },
                SecurityGroups: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      SecurityGroupId: {
                      },
                      Status: {
                      }
                    }
                  }
                },
                ReplicationGroupId: {
                }
              },
              wrapper: true,
              name: 'CacheCluster'
            }
          }
        }
      }
    },
    describeCacheEngineVersions: {
      name: 'DescribeCacheEngineVersions',
      input: {
        type: 'structure',
        members: {
          Engine: {
          },
          EngineVersion: {
          },
          CacheParameterGroupFamily: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          },
          DefaultOnly: {
            type: 'boolean'
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          CacheEngineVersions: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                Engine: {
                },
                EngineVersion: {
                },
                CacheParameterGroupFamily: {
                },
                CacheEngineDescription: {
                },
                CacheEngineVersionDescription: {
                }
              },
              name: 'CacheEngineVersion'
            }
          }
        }
      }
    },
    describeCacheParameterGroups: {
      name: 'DescribeCacheParameterGroups',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          CacheParameterGroups: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                CacheParameterGroupName: {
                },
                CacheParameterGroupFamily: {
                },
                Description: {
                }
              },
              wrapper: true,
              name: 'CacheParameterGroup'
            }
          }
        }
      }
    },
    describeCacheParameters: {
      name: 'DescribeCacheParameters',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
            required: true
          },
          Source: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          Parameters: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ParameterName: {
                },
                ParameterValue: {
                },
                Description: {
                },
                Source: {
                },
                DataType: {
                },
                AllowedValues: {
                },
                IsModifiable: {
                  type: 'boolean'
                },
                MinimumEngineVersion: {
                }
              },
              name: 'Parameter'
            }
          },
          CacheNodeTypeSpecificParameters: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ParameterName: {
                },
                Description: {
                },
                Source: {
                },
                DataType: {
                },
                AllowedValues: {
                },
                IsModifiable: {
                  type: 'boolean'
                },
                MinimumEngineVersion: {
                },
                CacheNodeTypeSpecificValues: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      CacheNodeType: {
                      },
                      Value: {
                      }
                    },
                    name: 'CacheNodeTypeSpecificValue'
                  }
                }
              },
              name: 'CacheNodeTypeSpecificParameter'
            }
          }
        }
      }
    },
    describeCacheSecurityGroups: {
      name: 'DescribeCacheSecurityGroups',
      input: {
        type: 'structure',
        members: {
          CacheSecurityGroupName: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          CacheSecurityGroups: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                OwnerId: {
                },
                CacheSecurityGroupName: {
                },
                Description: {
                },
                EC2SecurityGroups: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      Status: {
                      },
                      EC2SecurityGroupName: {
                      },
                      EC2SecurityGroupOwnerId: {
                      }
                    },
                    name: 'EC2SecurityGroup'
                  }
                }
              },
              wrapper: true,
              name: 'CacheSecurityGroup'
            }
          }
        }
      }
    },
    describeCacheSubnetGroups: {
      name: 'DescribeCacheSubnetGroups',
      input: {
        type: 'structure',
        members: {
          CacheSubnetGroupName: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          CacheSubnetGroups: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                CacheSubnetGroupName: {
                },
                CacheSubnetGroupDescription: {
                },
                VpcId: {
                },
                Subnets: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      SubnetIdentifier: {
                      },
                      SubnetAvailabilityZone: {
                        type: 'structure',
                        members: {
                          Name: {
                          }
                        },
                        wrapper: true
                      }
                    },
                    name: 'Subnet'
                  }
                }
              },
              wrapper: true,
              name: 'CacheSubnetGroup'
            }
          }
        }
      }
    },
    describeEngineDefaultParameters: {
      name: 'DescribeEngineDefaultParameters',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupFamily: {
            required: true
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          EngineDefaults: {
            type: 'structure',
            members: {
              CacheParameterGroupFamily: {
              },
              Marker: {
              },
              Parameters: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    ParameterName: {
                    },
                    ParameterValue: {
                    },
                    Description: {
                    },
                    Source: {
                    },
                    DataType: {
                    },
                    AllowedValues: {
                    },
                    IsModifiable: {
                      type: 'boolean'
                    },
                    MinimumEngineVersion: {
                    }
                  },
                  name: 'Parameter'
                }
              },
              CacheNodeTypeSpecificParameters: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    ParameterName: {
                    },
                    Description: {
                    },
                    Source: {
                    },
                    DataType: {
                    },
                    AllowedValues: {
                    },
                    IsModifiable: {
                      type: 'boolean'
                    },
                    MinimumEngineVersion: {
                    },
                    CacheNodeTypeSpecificValues: {
                      type: 'list',
                      members: {
                        type: 'structure',
                        members: {
                          CacheNodeType: {
                          },
                          Value: {
                          }
                        },
                        name: 'CacheNodeTypeSpecificValue'
                      }
                    }
                  },
                  name: 'CacheNodeTypeSpecificParameter'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    describeEvents: {
      name: 'DescribeEvents',
      input: {
        type: 'structure',
        members: {
          SourceIdentifier: {
          },
          SourceType: {
          },
          StartTime: {
            type: 'timestamp'
          },
          EndTime: {
            type: 'timestamp'
          },
          Duration: {
            type: 'integer'
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          Events: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                SourceIdentifier: {
                },
                SourceType: {
                },
                Message: {
                },
                Date: {
                  type: 'timestamp'
                }
              },
              name: 'Event'
            }
          }
        }
      }
    },
    describeReplicationGroups: {
      name: 'DescribeReplicationGroups',
      input: {
        type: 'structure',
        members: {
          ReplicationGroupId: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          ReplicationGroups: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ReplicationGroupId: {
                },
                Description: {
                },
                Status: {
                },
                PendingModifiedValues: {
                  type: 'structure',
                  members: {
                    PrimaryClusterId: {
                    }
                  }
                },
                MemberClusters: {
                  type: 'list',
                  members: {
                    name: 'ClusterId'
                  }
                },
                NodeGroups: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      NodeGroupId: {
                      },
                      Status: {
                      },
                      PrimaryEndpoint: {
                        type: 'structure',
                        members: {
                          Address: {
                          },
                          Port: {
                            type: 'integer'
                          }
                        }
                      },
                      NodeGroupMembers: {
                        type: 'list',
                        members: {
                          type: 'structure',
                          members: {
                            CacheClusterId: {
                            },
                            CacheNodeId: {
                            },
                            ReadEndpoint: {
                              type: 'structure',
                              members: {
                                Address: {
                                },
                                Port: {
                                  type: 'integer'
                                }
                              }
                            },
                            PreferredAvailabilityZone: {
                            },
                            CurrentRole: {
                            }
                          },
                          name: 'NodeGroupMember'
                        }
                      }
                    },
                    name: 'NodeGroup'
                  }
                }
              },
              wrapper: true,
              name: 'ReplicationGroup'
            }
          }
        }
      }
    },
    describeReservedCacheNodes: {
      name: 'DescribeReservedCacheNodes',
      input: {
        type: 'structure',
        members: {
          ReservedCacheNodeId: {
          },
          ReservedCacheNodesOfferingId: {
          },
          CacheNodeType: {
          },
          Duration: {
          },
          ProductDescription: {
          },
          OfferingType: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          ReservedCacheNodes: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ReservedCacheNodeId: {
                },
                ReservedCacheNodesOfferingId: {
                },
                CacheNodeType: {
                },
                StartTime: {
                  type: 'timestamp'
                },
                Duration: {
                  type: 'integer'
                },
                FixedPrice: {
                  type: 'float'
                },
                UsagePrice: {
                  type: 'float'
                },
                CacheNodeCount: {
                  type: 'integer'
                },
                ProductDescription: {
                },
                OfferingType: {
                },
                State: {
                },
                RecurringCharges: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      RecurringChargeAmount: {
                        type: 'float'
                      },
                      RecurringChargeFrequency: {
                      }
                    },
                    wrapper: true,
                    name: 'RecurringCharge'
                  }
                }
              },
              wrapper: true,
              name: 'ReservedCacheNode'
            }
          }
        }
      }
    },
    describeReservedCacheNodesOfferings: {
      name: 'DescribeReservedCacheNodesOfferings',
      input: {
        type: 'structure',
        members: {
          ReservedCacheNodesOfferingId: {
          },
          CacheNodeType: {
          },
          Duration: {
          },
          ProductDescription: {
          },
          OfferingType: {
          },
          MaxRecords: {
            type: 'integer'
          },
          Marker: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          Marker: {
          },
          ReservedCacheNodesOfferings: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ReservedCacheNodesOfferingId: {
                },
                CacheNodeType: {
                },
                Duration: {
                  type: 'integer'
                },
                FixedPrice: {
                  type: 'float'
                },
                UsagePrice: {
                  type: 'float'
                },
                ProductDescription: {
                },
                OfferingType: {
                },
                RecurringCharges: {
                  type: 'list',
                  members: {
                    type: 'structure',
                    members: {
                      RecurringChargeAmount: {
                        type: 'float'
                      },
                      RecurringChargeFrequency: {
                      }
                    },
                    wrapper: true,
                    name: 'RecurringCharge'
                  }
                }
              },
              wrapper: true,
              name: 'ReservedCacheNodesOffering'
            }
          }
        }
      }
    },
    modifyCacheCluster: {
      name: 'ModifyCacheCluster',
      input: {
        type: 'structure',
        members: {
          CacheClusterId: {
            required: true
          },
          NumCacheNodes: {
            type: 'integer'
          },
          CacheNodeIdsToRemove: {
            type: 'list',
            members: {
              name: 'CacheNodeId'
            }
          },
          CacheSecurityGroupNames: {
            type: 'list',
            members: {
              name: 'CacheSecurityGroupName'
            }
          },
          SecurityGroupIds: {
            type: 'list',
            members: {
              name: 'SecurityGroupId'
            }
          },
          PreferredMaintenanceWindow: {
          },
          NotificationTopicArn: {
          },
          CacheParameterGroupName: {
          },
          NotificationTopicStatus: {
          },
          ApplyImmediately: {
            type: 'boolean'
          },
          EngineVersion: {
          },
          AutoMinorVersionUpgrade: {
            type: 'boolean'
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheCluster: {
            type: 'structure',
            members: {
              CacheClusterId: {
              },
              ConfigurationEndpoint: {
                type: 'structure',
                members: {
                  Address: {
                  },
                  Port: {
                    type: 'integer'
                  }
                }
              },
              ClientDownloadLandingPage: {
              },
              CacheNodeType: {
              },
              Engine: {
              },
              EngineVersion: {
              },
              CacheClusterStatus: {
              },
              NumCacheNodes: {
                type: 'integer'
              },
              PreferredAvailabilityZone: {
              },
              CacheClusterCreateTime: {
                type: 'timestamp'
              },
              PreferredMaintenanceWindow: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  NumCacheNodes: {
                    type: 'integer'
                  },
                  CacheNodeIdsToRemove: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  },
                  EngineVersion: {
                  }
                }
              },
              NotificationConfiguration: {
                type: 'structure',
                members: {
                  TopicArn: {
                  },
                  TopicStatus: {
                  }
                }
              },
              CacheSecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheSecurityGroupName: {
                    },
                    Status: {
                    }
                  },
                  name: 'CacheSecurityGroup'
                }
              },
              CacheParameterGroup: {
                type: 'structure',
                members: {
                  CacheParameterGroupName: {
                  },
                  ParameterApplyStatus: {
                  },
                  CacheNodeIdsToReboot: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  }
                }
              },
              CacheSubnetGroupName: {
              },
              CacheNodes: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheNodeId: {
                    },
                    CacheNodeStatus: {
                    },
                    CacheNodeCreateTime: {
                      type: 'timestamp'
                    },
                    Endpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    ParameterGroupStatus: {
                    },
                    SourceCacheNodeId: {
                    }
                  },
                  name: 'CacheNode'
                }
              },
              AutoMinorVersionUpgrade: {
                type: 'boolean'
              },
              SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    SecurityGroupId: {
                    },
                    Status: {
                    }
                  }
                }
              },
              ReplicationGroupId: {
              }
            },
            wrapper: true
          }
        }
      }
    },
    modifyCacheParameterGroup: {
      name: 'ModifyCacheParameterGroup',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
            required: true
          },
          ParameterNameValues: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ParameterName: {
                },
                ParameterValue: {
                }
              },
              name: 'ParameterNameValue'
            },
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
          }
        }
      }
    },
    modifyCacheSubnetGroup: {
      name: 'ModifyCacheSubnetGroup',
      input: {
        type: 'structure',
        members: {
          CacheSubnetGroupName: {
            required: true
          },
          CacheSubnetGroupDescription: {
          },
          SubnetIds: {
            type: 'list',
            members: {
              name: 'SubnetIdentifier'
            }
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheSubnetGroup: {
            type: 'structure',
            members: {
              CacheSubnetGroupName: {
              },
              CacheSubnetGroupDescription: {
              },
              VpcId: {
              },
              Subnets: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    SubnetIdentifier: {
                    },
                    SubnetAvailabilityZone: {
                      type: 'structure',
                      members: {
                        Name: {
                        }
                      },
                      wrapper: true
                    }
                  },
                  name: 'Subnet'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    modifyReplicationGroup: {
      name: 'ModifyReplicationGroup',
      input: {
        type: 'structure',
        members: {
          ReplicationGroupId: {
            required: true
          },
          ReplicationGroupDescription: {
          },
          CacheSecurityGroupNames: {
            type: 'list',
            members: {
              name: 'CacheSecurityGroupName'
            }
          },
          SecurityGroupIds: {
            type: 'list',
            members: {
              name: 'SecurityGroupId'
            }
          },
          PreferredMaintenanceWindow: {
          },
          NotificationTopicArn: {
          },
          CacheParameterGroupName: {
          },
          NotificationTopicStatus: {
          },
          ApplyImmediately: {
            type: 'boolean'
          },
          EngineVersion: {
          },
          AutoMinorVersionUpgrade: {
            type: 'boolean'
          },
          PrimaryClusterId: {
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          ReplicationGroup: {
            type: 'structure',
            members: {
              ReplicationGroupId: {
              },
              Description: {
              },
              Status: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  PrimaryClusterId: {
                  }
                }
              },
              MemberClusters: {
                type: 'list',
                members: {
                  name: 'ClusterId'
                }
              },
              NodeGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    NodeGroupId: {
                    },
                    Status: {
                    },
                    PrimaryEndpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    NodeGroupMembers: {
                      type: 'list',
                      members: {
                        type: 'structure',
                        members: {
                          CacheClusterId: {
                          },
                          CacheNodeId: {
                          },
                          ReadEndpoint: {
                            type: 'structure',
                            members: {
                              Address: {
                              },
                              Port: {
                                type: 'integer'
                              }
                            }
                          },
                          PreferredAvailabilityZone: {
                          },
                          CurrentRole: {
                          }
                        },
                        name: 'NodeGroupMember'
                      }
                    }
                  },
                  name: 'NodeGroup'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    purchaseReservedCacheNodesOffering: {
      name: 'PurchaseReservedCacheNodesOffering',
      input: {
        type: 'structure',
        members: {
          ReservedCacheNodesOfferingId: {
            required: true
          },
          ReservedCacheNodeId: {
          },
          CacheNodeCount: {
            type: 'integer'
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          ReservedCacheNode: {
            type: 'structure',
            members: {
              ReservedCacheNodeId: {
              },
              ReservedCacheNodesOfferingId: {
              },
              CacheNodeType: {
              },
              StartTime: {
                type: 'timestamp'
              },
              Duration: {
                type: 'integer'
              },
              FixedPrice: {
                type: 'float'
              },
              UsagePrice: {
                type: 'float'
              },
              CacheNodeCount: {
                type: 'integer'
              },
              ProductDescription: {
              },
              OfferingType: {
              },
              State: {
              },
              RecurringCharges: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    RecurringChargeAmount: {
                      type: 'float'
                    },
                    RecurringChargeFrequency: {
                    }
                  },
                  wrapper: true,
                  name: 'RecurringCharge'
                }
              }
            },
            wrapper: true
          }
        }
      }
    },
    rebootCacheCluster: {
      name: 'RebootCacheCluster',
      input: {
        type: 'structure',
        members: {
          CacheClusterId: {
            required: true
          },
          CacheNodeIdsToReboot: {
            type: 'list',
            members: {
              name: 'CacheNodeId'
            },
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheCluster: {
            type: 'structure',
            members: {
              CacheClusterId: {
              },
              ConfigurationEndpoint: {
                type: 'structure',
                members: {
                  Address: {
                  },
                  Port: {
                    type: 'integer'
                  }
                }
              },
              ClientDownloadLandingPage: {
              },
              CacheNodeType: {
              },
              Engine: {
              },
              EngineVersion: {
              },
              CacheClusterStatus: {
              },
              NumCacheNodes: {
                type: 'integer'
              },
              PreferredAvailabilityZone: {
              },
              CacheClusterCreateTime: {
                type: 'timestamp'
              },
              PreferredMaintenanceWindow: {
              },
              PendingModifiedValues: {
                type: 'structure',
                members: {
                  NumCacheNodes: {
                    type: 'integer'
                  },
                  CacheNodeIdsToRemove: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  },
                  EngineVersion: {
                  }
                }
              },
              NotificationConfiguration: {
                type: 'structure',
                members: {
                  TopicArn: {
                  },
                  TopicStatus: {
                  }
                }
              },
              CacheSecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheSecurityGroupName: {
                    },
                    Status: {
                    }
                  },
                  name: 'CacheSecurityGroup'
                }
              },
              CacheParameterGroup: {
                type: 'structure',
                members: {
                  CacheParameterGroupName: {
                  },
                  ParameterApplyStatus: {
                  },
                  CacheNodeIdsToReboot: {
                    type: 'list',
                    members: {
                      name: 'CacheNodeId'
                    }
                  }
                }
              },
              CacheSubnetGroupName: {
              },
              CacheNodes: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    CacheNodeId: {
                    },
                    CacheNodeStatus: {
                    },
                    CacheNodeCreateTime: {
                      type: 'timestamp'
                    },
                    Endpoint: {
                      type: 'structure',
                      members: {
                        Address: {
                        },
                        Port: {
                          type: 'integer'
                        }
                      }
                    },
                    ParameterGroupStatus: {
                    },
                    SourceCacheNodeId: {
                    }
                  },
                  name: 'CacheNode'
                }
              },
              AutoMinorVersionUpgrade: {
                type: 'boolean'
              },
              SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    SecurityGroupId: {
                    },
                    Status: {
                    }
                  }
                }
              },
              ReplicationGroupId: {
              }
            },
            wrapper: true
          }
        }
      }
    },
    resetCacheParameterGroup: {
      name: 'ResetCacheParameterGroup',
      input: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
            required: true
          },
          ResetAllParameters: {
            type: 'boolean'
          },
          ParameterNameValues: {
            type: 'list',
            members: {
              type: 'structure',
              members: {
                ParameterName: {
                },
                ParameterValue: {
                }
              },
              name: 'ParameterNameValue'
            },
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheParameterGroupName: {
          }
        }
      }
    },
    revokeCacheSecurityGroupIngress: {
      name: 'RevokeCacheSecurityGroupIngress',
      input: {
        type: 'structure',
        members: {
          CacheSecurityGroupName: {
            required: true
          },
          EC2SecurityGroupName: {
            required: true
          },
          EC2SecurityGroupOwnerId: {
            required: true
          }
        }
      },
      output: {
        type: 'structure',
        members: {
          CacheSecurityGroup: {
            type: 'structure',
            members: {
              OwnerId: {
              },
              CacheSecurityGroupName: {
              },
              Description: {
              },
              EC2SecurityGroups: {
                type: 'list',
                members: {
                  type: 'structure',
                  members: {
                    Status: {
                    },
                    EC2SecurityGroupName: {
                    },
                    EC2SecurityGroupOwnerId: {
                    }
                  },
                  name: 'EC2SecurityGroup'
                }
              }
            },
            wrapper: true
          }
        }
      }
    }
  },
  pagination: {
    describeCacheClusters: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'CacheClusters'
    },
    describeCacheEngineVersions: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'CacheEngineVersions'
    },
    describeCacheParameterGroups: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'CacheParameterGroups'
    },
    describeCacheParameters: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'Parameters'
    },
    describeCacheSecurityGroups: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'CacheSecurityGroups'
    },
    describeCacheSubnetGroups: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'CacheSubnetGroups'
    },
    describeEngineDefaultParameters: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'Parameters'
    },
    describeEvents: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'Events'
    },
    describeReservedCacheNodes: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'ReservedCacheNodes'
    },
    describeReservedCacheNodesOfferings: {
      inputToken: 'Marker',
      outputToken: 'Marker',
      limitKey: 'MaxRecords',
      resultKey: 'ReservedCacheNodesOfferings'
    }
  }
};


text:
ENV['ANSIBLE_CONFIG'] = ANSIBLE_PATH
ENV['ANSIBLE_CALLBACK_PLUGINS'] = "~/.ansible/plugins/callback_plugins/:/usr/share/ansible_plugins/callback_plugins:#{File.join(ANSIBLE_PATH, 'lib/trellis/plugins/callback')}"
ENV['ANSIBLE_FILTER_PLUGINS'] = "~/.ansible/plugins/filter_plugins/:/usr/share/ansible_plugins/filter_plugins:#{File.join(ANSIBLE_PATH, 'lib/trellis/plugins/filter')}"
ENV['ANSIBLE_LIBRARY'] = "/usr/share/ansible:#{File.join(ANSIBLE_PATH, 'lib/trellis/modules')}"
ENV['ANSIBLE_ROLES_PATH'] = File.join(ANSIBLE_PATH, 'vendor', 'roles')
ENV['ANSIBLE_VARS_PLUGINS'] = "~/.ansible/plugins/vars_plugins/:/usr/share/ansible_plugins/vars_plugins:#{File.join(ANSIBLE_PATH, 'lib/trellis/plugins/vars')}"

def ensure_plugins(plugins)
  logger = Vagrant::UI::Colored.new
  installed = false

  plugins.each do |plugin|
    plugin_name = plugin['name']
    manager = Vagrant::Plugin::Manager.instance

    next if manager.installed_plugins.has_key?(plugin_name)

    logger.warn("Installing plugin #{plugin_name}")

    manager.install_plugin(
      plugin_name,
      sources: plugin.fetch('source', %w(https://rubygems.org/ https://gems.hashicorp.com/)),
      version: plugin['version']
    )

    installed = true
  end

  if installed
    logger.warn('`vagrant up` must be re-run now that plugins are installed')
    exit
  end
end

def fail_with_message(msg)
  fail Vagrant::Errors::VagrantError.new, msg
end

def hosts(sites)
  site_hosts = sites.flat_map { |(_name, site)| site['site_hosts'] }

  site_hosts.each do |host|
    if !host.is_a?(Hash) || !host.has_key?('canonical')
      fail_with_message File.read(File.join(ANSIBLE_PATH, 'roles/common/templates/site_hosts.j2')).sub!('{{ env }}', 'development').gsub!(/com$/, 'dev')
    end
  end

  site_hosts
end

def load_wordpress_sites
  config_file = File.join(ANSIBLE_PATH, 'group_vars', 'development', 'wordpress_sites.yml')

  if File.exists?(config_file)
    wordpress_sites = YAML.load_file(config_file)['wordpress_sites']
    fail_with_message "No sites found in #{config_file}." if wordpress_sites.to_h.empty?
  else
    fail_with_message "#{config_file} was not found. Please set `ANSIBLE_PATH` in your Vagrantfile."
  end

  wordpress_sites
end

def local_site_path(site)
  File.expand_path(site['local_path'], ANSIBLE_PATH)
end

def multisite_subdomains?(wordpress_sites)
  wordpress_sites.any? do |(_name, site)|
    site['multisite'].fetch('enabled', false) && site['multisite'].fetch('subdomains', false)
  end
end

def nfs_path(path)
  "/vagrant-nfs-#{File.basename(path)}"
end

def post_up_message
  msg = 'Your Trellis Vagrant box is ready to use!'
  msg << "\n* Composer and WP-CLI commands need to be run on the virtual machine."
  msg << "\n* You can SSH into the machine with `vagrant ssh`."
  msg << "\n* Then navigate to your WordPress sites at `/srv/www`"
  msg << "\n  or to your Trellis files at `#{ANSIBLE_PATH_ON_VM}`."

  msg
end

def remote_site_path(site_name, site)
  "/srv/www/#{site_name}/#{site['current_path'] || 'current'}"
end

redpajama_set_name: RedPajamaGithub


text:
@implementation SMTopWindow

static UIWindow *topWinow;

+ (void)initialize {
    topWinow = [[UIWindow alloc] init];
    topWinow.frame = CGRectMake(0, 0, [UIScreen mainScreen].bounds.size.width, 20);
    topWinow.windowLevel = UIWindowLevelAlert;
    [topWinow addGestureRecognizer:[[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(winTap)]];
}

+ (void)work {
    topWinow.hidden = NO;
}

//点击时
+ (void)winTap {
    UIWindow *window = [UIApplication sharedApplication].keyWindow;
    [self seachScrollViewInView:window];
}

//递归搜索所有view查找当前位置合适的scroll view
+ (void)seachScrollViewInView:(UIView *)view {
    for (UIScrollView *subView in view.subviews) {
        if ([subView isKindOfClass:[UIScrollView class]] && [self isCurrentShowView:subView]) {
            //开始进行滚动
            CGPoint offset = subView.contentOffset;
            offset.y = -subView.contentInset.top;
            [subView setContentOffset:offset animated:YES];
        }
        //寻找子视图的子视图
        [self seachScrollViewInView:subView];
    }
}

//根据位置判断是否合适
+ (BOOL)isCurrentShowView:(UIView *)view {
    UIWindow *keyWindow = [UIApplication sharedApplication].keyWindow;
    CGRect currentFrame = [keyWindow convertRect:view.frame fromView:view.superview];
    CGRect winBounds = keyWindow.bounds;
    BOOL intersects = CGRectIntersectsRect(currentFrame, winBounds);
    return !view.isHidden && view.alpha > 0.01 && view.window == keyWindow && intersects;

}
@end


text:
package org.apache.lucene.search;

import org.apache.lucene.index.Term;

/**
 * A Filter that restricts search results to values that have a matching prefix in a given
 * field.
 */
public class PrefixFilter extends MultiTermQueryWrapperFilter {

  public PrefixFilter(Term prefix) {
    super(new PrefixQuery(prefix));
  }

  public Term getPrefix() { return ((PrefixQuery)query).getPrefix(); }

  /** Prints a user-readable version of this query. */
  public String toString () {
    StringBuffer buffer = new StringBuffer();
    buffer.append("PrefixFilter(");
    buffer.append(getPrefix().toString());
    buffer.append(")");
    return buffer.toString();
  }

}


text:
namespace Draw2D.ViewModels.Style
{
    public interface IShapeStyle : INode, IDirty, ICopyable
    {
        bool IsStroked { get; set; }
        bool IsFilled { get; set; }
        bool IsText { get; set; }
        IPaint StrokePaint { get; set; }
        IPaint FillPaint { get; set; }
        IPaint TextPaint { get; set; }
    }
}


text:
* Added *LRGASP* and *ENCYCLOPEDIAv6* to the *internal_tags* enums list
* Added *doi* property
* Added *analyses* property
* Added *RushAD* and *YaleImmuneCells* to the *internal_tags* enum
* Added *Deeply Profiled* to the *internal_tags* enum
* Added *Degron* to *internal_tags* enums list.

### Schema version 17

* Update the dbxref regex to remove IHEC; this is only allowed for Annotation and ReferenceEpigenome objects

### Schema version 16

* Update IHEC dbxref regex to remove version number

### Minor changes since schema version 15

* *references* was set to have a minimum of 1.
* Added *MouseDevSeries* enum to *internal_tags*
* Removed *month_released* calculated property.

### Schema version 15

* *internal_tags* removes *cre_inputv10* and *cre_inputv11*, and adds *ENCYCLOPEDIAv5*, *ccre_inputv1*, and *ccre_inputv2*.

### Schema version 14

* Replace *started* enum in *status* with *in progress*.

### Schema version 13

* Remove *proposed* from *status* enum (*dataset* mixin).

### Schema version 12

* *alternate_accessions* now must match accession format, "ENCSR..." or "TSTSR..."


text:
var Imported = Imported || {};
Imported.Online_Network_Players = true;

(function () {
var Nasty = Nasty || {};
//=============================================================================
// Online Network Players
// Version: 1.0.10 - Fixed bug when in battle sprites clearing on map.
// Version: 1.0.9 - Added check to stop Game_Player refresh when null
// Version: 1.0.8 - Fixed bug for remove player when not on map
// Version: 1.0.7 - Fixed bug with NastyTextPop not being there
// Version: 1.0.6 - Added names above characters with Nasty_Text_Pop_Events.js
//=============================================================================

//=============================================================================
 /*:
 * @plugindesc Network Players for Neldersons Online Core
 *<Online_Network_Players>
 * @author Nelderson and Galv
 *
 * @param Net Player Map ID
 * @desc Map ID for Net Player Spawn Event
 * @default 1
 *
 * @param Net Player Event ID
 * @desc Event ID for Net Player Spawn Event
 * @default 1
 *
 * @param Show Username or Character Name
 * @desc 0=Username, 1=Character Name
 * @default 0
 *
 * @param Show Name Above Players Head
 * @type boolean
 * @on Yes
 * @off No
 * @desc Shows Username/Character name over Players Head
 * @default true
 *
 * @param Player Text Options
 * @desc This refers to the number in Nasty_Text_Pop_Events for text options
 * @default 1
 *
 * @param Net Player Text Options
 * @desc This refers to the number in Nasty_Text_Pop_Events for text options
 * @default 1
 *
 * @help
 * ============================================================================
 * Introduction and Instructions
 * ============================================================================
 * This plugin allows you to see other players on the map.
 * Add Nasty_Text_Pop_Events.js to see players names above their character
 *
 *  Plugin Parameters:
 *
 *  1.  Net Player Map ID
 *      -The Map ID the Netplayer Spawn event is located
 *
 *  2.  Net Player Event ID
 *      -The Event ID the Netplayer Spawn event is located
 */
 //=============================================================================

 Nasty.Parameters = $plugins.filter(function(p)
	 { return p.description.contains('<Online_Network_Players>');})[0].parameters;

var NetPlayerMap = Nasty.Parameters['Net Player Map ID'];
var NetPlayerEventID = Nasty.Parameters['Net Player Event ID'];
var NetPlayerNameType = Number(Nasty.Parameters['Show Username or Character Name']);
var showPlayersName = String(Nasty.Parameters['Show Name Above Players Head']);
var playerTextOptions = (Number(Nasty.Parameters['Player Text Options'])-1);
var netplayerTextOptions = (Number(Nasty.Parameters['Net Player Text Options'])-1);

var networkName = '';
var socket;
var networkPlayerid = 0;
var networkMapEvents = {};
var NetworkFlag = false;

var OnlineMV_NetPlayer_SocketConn_Alias = Game_Network.prototype.connectSocketsAfterLogin;
Game_Network.prototype.connectSocketsAfterLogin = function(){
	OnlineMV_NetPlayer_SocketConn_Alias.call(this);

	$gameNetwork.connectSocket('netplayers','/netplayers',false);
	socket = $gameNetwork._socket.netplayers;

	socket.on('MyID',function(data){
		networkPlayerid = data.id; //Set Network ID
		currentRoom = data.room;
		NetworkFlag = true;
    if (NetPlayerNameType===0){
      networkName = data.name;
    }
	});

	socket.on('NetworkPlayersXY', function(data){
    if(!SceneManager._scene._spriteset || SceneManager._scene instanceof Scene_Battle) return;
		var player = data.playerid;
    var name = data.name;
		var cx = data.x;
		var cy = data.y;
		var moveSpeed = data.moveSpeed;
		var moveFrequenzy = data.moveFrequenzy;
		var characterName = data.characterName;
		var characterIndex = data.characterIndex;

		//Make an event if net player isn't already there
		if (networkMapEvents[player]===undefined){
			var NetEvent = $gameMap.addNetworkPlayer(1, 1,name);
			networkMapEvents[player] = NetEvent;
		}
    networkMapEvents[player].namepop = name;
    networkMapEvents[player].textpop_flag = true;

		// Update movement speed and frequenzy
		networkMapEvents[player].setMoveSpeed(moveSpeed);
		networkMapEvents[player].setMoveFrequency(moveFrequenzy);

		//Continue on with updating xy position
		var dir = data.direction;
		networkMapEvents[player].moveStraight(dir);
		//Sanity Check XY position
		if (networkMapEvents[player].x!==data.x || networkMapEvents[player].y!==data.y){
			networkMapEvents[player].setPosition(data.x, data.y);
		}
		//Set Player Sprite
		networkMapEvents[player]._characterName = characterName;
		networkMapEvents[player]._characterIndex = characterIndex;
	 });

	 socket.on('changeRoomVar', function(data){
		 currentRoom = data;
		 networkMapEvents = {};
	 });

	 socket.on('removePlayer', function(data){
     if(!SceneManager._scene._spriteset || SceneManager._scene instanceof Scene_Battle) return;
		 var id = data.id;
		 //Just in case player hasn't moved and disconnects
		 if (!networkMapEvents[id]) return;
		 var player = networkMapEvents[id]._eventId;
		 var map = data.room;
		 $gameMap.clearNetworkPlayer(player);
		 delete networkMapEvents[id];
	 });
};

//================//
//Player Movement
//================//
Game_Player.prototype.moveByInput = function() {
		if (!this.isMoving() && this.canMove()) {
				var direction = this.getInputDirection();
				if (direction > 0) {
						$gameTemp.clearDestination();
				} else if ($gameTemp.isDestinationValid()){
						var x = $gameTemp.destinationX();
						var y = $gameTemp.destinationY();
						direction = this.findDirectionTo(x, y);
				}
				if (direction > 0) {
          if (NetPlayerNameType===1) networkName=$gameParty.leader()._name;
					//Send x,y info to server
						this.executeMove(direction);
						if (NetworkFlag){
						socket.emit('DestinationXY', {
							playerid: networkPlayerid,
							direction: direction,
              name: networkName,
							x: this.x,
							y: this.y,
							moveSpeed: this.realMoveSpeed(),
							moveFrequenzy: this.moveFrequency(),
							characterName: this._characterName,
							characterIndex: this._characterIndex
						});
					}
				}
		}
};

//=================================//
//Player Refresh for Text Over Self
//=================================//
var NetPlayer_GmePlayer_refresh_alias = Game_Player.prototype.refresh;
Game_Player.prototype.refresh = function() {
  NetPlayer_GmePlayer_refresh_alias.call(this);
  if(this.namepop===undefined) return;
  if (showPlayersName==='false') return;
    if (NetPlayerNameType===1) {
      this.namepop = $gameParty.leader()._name;
    }else{
      this.namepop = networkName;
    }
    this.setTextOptions(playerTextOptions);
};

var NetPlayer_SceneBase_popScene = Scene_Base.prototype.popScene;
Scene_Base.prototype.popScene = function() {
    NetPlayer_SceneBase_popScene.call(this);
    if ($gamePlayer) $gamePlayer.refresh();
};

var NetPlayer_SceneBase_stop = Scene_Base.prototype.stop;
Scene_Base.prototype.stop = function() {
    NetPlayer_SceneBase_stop.call(this);
    if ($gamePlayer) $gamePlayer.refresh();
};

//==============================//
//Room Change When Changing Maps
//==============================//
var NetPlayer_SceneMap_Start_Alias = Scene_Map.prototype.start;
Scene_Map.prototype.start = function() {
	NetPlayer_SceneMap_Start_Alias.call(this);
	var mapId = $gameMap.mapId();
	if (NetworkFlag){
    //In case of menu or battle scene
		if (currentRoom !== mapId.toString()){
			socket.emit('changeRoom', mapId.toString());
		}
	}
};

var Online_NetPlayers_Map_CallMenu_Alias = Scene_Map.prototype.callMenu;
Scene_Map.prototype.callMenu = function() {
  $gameMap.clearAllNetworkPlayerEvents();
  networkMapEvents = {};
  Online_NetPlayers_Map_CallMenu_Alias.call(this);
};

//========================//
//Net Player Event Creator
//========================//
DataManager.loadNetworkPlayerMapData = function() {
	var mapId = NetPlayerMap;
  var filename = 'Map%1.json'.format(mapId.padZero(3));
  this.loadDataFile('$networkPlayerMap', filename);
};

DataManager.loadNetworkPlayerMapData();

Game_Map.prototype.addNetworkPlayer = function(x,y,playerid) {
    var eId = this._events.length;
    this._events[eId] = new Game_NetworkPlayer(this._mapId,eId,x,y, playerid);
	  SceneManager._scene._spriteset.createNetworkPlayer(eId);
		return this._events[eId];
};

Game_Map.prototype.clearNetworkPlayer = function(eId) {
	this._events[eId] = null;
	SceneManager._scene._spriteset.clearNetworkPlayer(eId);
};

Game_Map.prototype.clearAllNetworkPlayerEvents = function() {
  for (var i = 1; i < this._events.length; i++) {
    if (!this._events[i]) continue;
    if (this._events[i]._isNetworkPlayer){
      this._events[i] = null;
    }
    SceneManager._scene._spriteset.clearAllNetworkPlayerEvents();
  }
  this.removeNullEvents();
};

Game_Map.prototype.removeNullEvents = function() {
	for (var i = this._events.length - 1; i > 0; i--) {
		if (this._events[i] === null) {
			this._events.splice(i, 1);
		} else {
			break;
		}
	}
};

Spriteset_Map.prototype.createNetworkPlayer = function(id) {
	var event = $gameMap._events[id];
	var sId = this._characterSprites.length;
	this._characterSprites[sId] = new Sprite_Character(event);
	this._characterSprites[sId].update(); // To remove occsaional full-spriteset visible issue
	this._tilemap.addChild(this._characterSprites[sId]);
};

Spriteset_Map.prototype.clearNetworkPlayer = function(eId) {
	for (var i = 0; i < this._characterSprites.length; i++) {
		var event = this._characterSprites[i]._character;
		if (event._isNetworkPlayer && eId == event._eventId) {
			this._tilemap.removeChild(this._characterSprites[i]);
		}
	}
};

Spriteset_Map.prototype.clearAllNetworkPlayerEvents = function() {
	for (var i = 0; i < this._characterSprites.length; i++) {
		var event = this._characterSprites[i]._character;
		if (event._isNetworkPlayer) {
			this._tilemap.removeChild(this._characterSprites[i]);
		}
	}
};

function Game_NetworkPlayer() {
    this.initialize.apply(this, arguments);
}

Game_NetworkPlayer.prototype = Object.create(Game_Event.prototype);
Game_NetworkPlayer.prototype.constructor = Game_NetworkPlayer;

Game_NetworkPlayer.prototype.initialize = function(mapId,eventId,x,y, name) {
	Game_Event.prototype.initialize.call(this,mapId,eventId);
  this._isNetworkPlayer = true;
  this.setPosition(x,y);
  if (this.namepop===undefined){
    console.log("You need Nasty_Text_Pop_Events for names to show!");
  }else{
    this.namepop = name;
    this.setTextOptions(netplayerTextOptions);
  }
};

Game_NetworkPlayer.prototype.event = function() {
    return $networkPlayerMap.events[NetPlayerEventID];
};

})();


text:
<?php
require_once('common.php');

//system("gpio mode 7 out");
//$res = system("gpio read 0 ");

$result['state']  = 1;
$result['error']  = system("gpio read 0");
echo '('.json_encode($result).')';

?>


text:
<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Models\Exception;

/**
 * Errors raised by Entity logic in runtime.
 */
class EntityException extends \RuntimeException implements EntityExceptionInterface
{
}


text:
package org.opencb.hpg.bigdata.analysis.tools.manifest;

/**
 * Created by pfurio on 23/05/17.
 */
public class ProgrammingLanguage {

    private String name;
    private String version;

    public ProgrammingLanguage() {
    }

    public ProgrammingLanguage(String name, String version) {
        this.name = name;
        this.version = version;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("ProgrammingLanguage{");
        sb.append("name='").append(name).append('\'');
        sb.append(", version='").append(version).append('\'');
        sb.append('}');
        return sb.toString();
    }

    public String getName() {
        return name;
    }

    public ProgrammingLanguage setName(String name) {
        this.name = name;
        return this;
    }

    public String getVersion() {
        return version;
    }

    public ProgrammingLanguage setVersion(String version) {
        this.version = version;
        return this;
    }

}


text:
package org.apache.juddi.api.impl;

import javax.xml.ws.WebServiceContext;

/**
 * This is used
 * @author Alex O'Ree
 */
public class UDDISecurityImplExt extends UDDISecurityImpl{
 /**
     * used for unit tests only
     *
     * @param ctx
     */
    protected UDDISecurityImplExt(WebServiceContext ctx) {
        super();
        this.ctx = ctx;
    }
}


text:
<?php
/**
 * @author @jenschude <jens.schulze@commercetools.de>
 */

namespace Commercetools\Core\Request\Payments;

use Commercetools\Core\Model\Common\Context;
use Commercetools\Core\Request\AbstractUpdateRequest;
use Commercetools\Core\Model\Payment\Payment;
use Commercetools\Core\Response\ApiResponseInterface;
use Commercetools\Core\Model\MapperInterface;

/**
 * @package Commercetools\Core\Request\Payments
 * @link https://docs.commercetools.com/http-api-projects-payments.html#update-payment
 * @method Payment mapResponse(ApiResponseInterface $response)
 * @method Payment mapFromResponse(ApiResponseInterface $response, MapperInterface $mapper = null)
 */
class PaymentUpdateRequest extends AbstractUpdateRequest
{
    protected $resultClass = Payment::class;

    /**
     * @param string $id
     * @param int $version
     * @param array $actions
     * @param Context $context
     */
    public function __construct($id, $version, array $actions = [], Context $context = null)
    {
        parent::__construct(PaymentsEndpoint::endpoint(), $id, $version, $actions, $context);
    }

    /**
     * @param string $id
     * @param int $version
     * @param Context $context
     * @return static
     */
    public static function ofIdAndVersion($id, $version, Context $context = null)
    {
        return new static($id, $version, [], $context);
    }
}


text:
!function (a) {
    function b() {
    }

    function c(a) {
        !f && window && window.console && (f = !0, console.log("Deprecated TinyMCE API call: " + a))
    }

    function d(a, d, e, f) {
        return a = a || this, d ? (this.add = function (b, g, h) {
            function i(c) {
                var h = [];
                if ("string" == typeof e && (e = e.split(" ")), e && "function" != typeof e)for (var i = 0; i < e.length; i++)h.push(c[e[i]]);
                ("function" != typeof e || (h = e(d, c, a))) && (e || (h = [c]), h.unshift(f || a), b.apply(g || f || a, h) === !1 && c.stopImmediatePropagation())
            }

            return c("<target>.on" + d + ".add(..)"), a.on(d, i, h), i
        }, this.addToTop = function (a, b) {
            this.add(a, b, !0)
        }, this.remove = function (b) {
            return a.off(d, b)
        }, void(this.dispatch = function () {
            return a.fire(d), !0
        })) : void(this.add = this.addToTop = this.remove = this.dispatch = b)
    }

    function e(e) {
        function f(b, c) {
            a.each(b.split(" "), function (a) {
                e["on" + a] = new d(e, a, c)
            })
        }

        function g(a, b, c) {
            return [b.level, c]
        }

        function h(a) {
            return function (b, c) {
                return !c.selection && !a || c.selection == a ? [c] : void 0
            }
        }

        function i() {
            function b() {
                return i()
            }

            var d = {}, e = "add addMenu addSeparator collapse createMenu destroy displayColor expand focus getLength hasMenus hideMenu isActive isCollapsed isDisabled isRendered isSelected mark postRender remove removeAll renderHTML renderMenu renderNode renderTo select selectByIndex setActive setAriaProperty setColor setDisabled setSelected setState showMenu update";
            return c("editor.controlManager.*"), a.each(e.split(" "), function (a) {
                d[a] = b
            }), d
        }

        if (!e.controlManager) {
            e.controlManager = {
                buttons: {},
                setDisabled: function (a, b) {
                    c("controlManager.setDisabled(..)"), this.buttons[a] && this.buttons[a].disabled(b)
                },
                setActive: function (a, b) {
                    c("controlManager.setActive(..)"), this.buttons[a] && this.buttons[a].active(b)
                },
                onAdd: new d,
                onPostRender: new d,
                add: function (a) {
                    return a
                },
                createButton: i,
                createColorSplitButton: i,
                createControl: i,
                createDropMenu: i,
                createListBox: i,
                createMenuButton: i,
                createSeparator: i,
                createSplitButton: i,
                createToolbar: i,
                createToolbarGroup: i,
                destroy: b,
                get: b,
                setControlType: i
            }, f("PreInit BeforeRenderUI PostRender Load Init Remove Activate Deactivate", "editor"), f("Click MouseUp MouseDown DblClick KeyDown KeyUp KeyPress ContextMenu Paste Submit Reset"), f("BeforeExecCommand ExecCommand", "command ui value args"), f("PreProcess PostProcess LoadContent SaveContent Change"), f("BeforeSetContent BeforeGetContent SetContent GetContent", h(!1)), f("SetProgressState", "state time"), f("VisualAid", "element hasVisual"), f("Undo Redo", g), f("NodeChange", function (a, b) {
                return [e.controlManager, b.element, e.selection.isCollapsed(), b]
            });
            var j = e.addButton;
            e.addButton = function (b, c) {
                function d() {
                    return e.controlManager.buttons[b] = this, f ? f.call(this) : void 0
                }

                var f, g, h;
                for (var i in c)"onpostrender" === i.toLowerCase() && (f = c[i], c.onPostRender = d);
                return f || (c.onPostRender = d), c.title && (g = (e.settings.language || "en") + "." + c.title, h = a.i18n.translate(g), g !== h && (c.title = h)), j.call(this, b, c)
            }, e.on("init", function () {
                var a = e.undoManager, b = e.selection;
                a.onUndo = new d(e, "Undo", g, null, a), a.onRedo = new d(e, "Redo", g, null, a), a.onBeforeAdd = new d(e, "BeforeAddUndo", null, a), a.onAdd = new d(e, "AddUndo", null, a), b.onBeforeGetContent = new d(e, "BeforeGetContent", h(!0), b), b.onGetContent = new d(e, "GetContent", h(!0), b), b.onBeforeSetContent = new d(e, "BeforeSetContent", h(!0), b), b.onSetContent = new d(e, "SetContent", h(!0), b)
            }), e.on("BeforeRenderUI", function () {
                var b = e.windowManager;
                b.onOpen = new d, b.onClose = new d, b.createInstance = function (b, d, e, f, g, h) {
                    c("windowManager.createInstance(..)");
                    var i = a.resolve(b);
                    return new i(d, e, f, g, h)
                }
            })
        }
    }

    var f;
    a.util.Dispatcher = d, a.onBeforeUnload = new d(a, "BeforeUnload"), a.onAddEditor = new d(a, "AddEditor", "editor"), a.onRemoveEditor = new d(a, "RemoveEditor", "editor"), a.util.Cookie = {
        get: b,
        getHash: b,
        remove: b,
        set: b,
        setHash: b
    }, a.on("SetupEditor", e), a.PluginManager.add("compat3x", e), a.addI18n = function (b, c) {
        var d = a.util.I18n, e = a.each;
        return "string" == typeof b && -1 === b.indexOf(".") ? void d.add(b, c) : void(a.is(b, "string") ? e(c, function (a, c) {
            d.data[b + "." + c] = a
        }) : e(b, function (a, b) {
            e(a, function (a, c) {
                e(a, function (a, e) {
                    "common" === c ? d.data[b + "." + e] = a : d.data[b + "." + c + "." + e] = a
                })
            })
        }))
    }
}(tinymce);