public abstract class BaseClient : IDisposable

{

public EventHandler<GettingAccessTokenEventArgs> GettingAccessToken;

public EventHandler<SendingWebRequestEventArgs> SendingWebRequest;

protected BaseClient();

protected BaseClient(string clientId, string clientSecret);

public string ClientId { get; set; }

public string ClientSecret { get; set; }

public Collection<Uri> BaseUris { get; }

protected WebResponse SendWebRequest(WebRequest webRequest);

protected Task<WebResponse> SendWebRequestAsync(WebRequest webRequest);

protected string GetNextCandidateBaseUri();//?

protected virtual string GetNextCandidateBaseUriCore();

protected virtual void OnGettingAccessToken(GettingAccessTokenEventArgs e);

protected virtual void OnSendingWebRequest(SendingWebRequestEventArgs e);

public virtual void Dispose();

}

public class ColorClient : BaseClient, IDisposable

{

public ColorClient();

public ColorClient(string clientId, string clientSecret);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInAnalogousFamily(int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInAnalogousFamilyAsync(int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInAnalogousFamily(GeoColor color, int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInAnalogousFamilyAsync(GeoColor color, int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInComplementaryFamily(int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInComplementaryFamilyAsync(int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInComplementaryFamily(GeoColor color, int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInComplementaryFamilyAsync(GeoColor color, int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInContrastingFamily(int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInContrastingFamilyAsync(int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInContrastingFamily(GeoColor color, int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInContrastingFamilyAsync(GeoColor color, int numberOfColors);

public Collection<GeoColor> GetColorsInHueFamily(int numberOfColors);

public Task<Collection<GeoColor>> GetColorsInHueFamilyAsync(int numberOfColors);

public Collection<GeoColor> GetColorsInHueFamily(GeoColor color, int numberOfColors);

public Task<Collection<GeoColor>> GetColorsInHueFamilyAsync(GeoColor color, int numberOfColors);

public Collection<GeoColor> GetColorsInQualityFamily(int numberOfColors);

public Task<Collection<GeoColor>> GetColorsInQualityFamilyAsync(int numberOfColors);

public Collection<GeoColor> GetColorsInQualityFamily(GeoColor color, int numberOfColors);

public Task<Collection<GeoColor>> GetColorsInQualityFamilyAsync(GeoColor color, int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInTetradFamily(int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInTetradFamilyAsync(int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInTetradFamily(GeoColor color, int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInTetradFamilyAsync(GeoColor color, int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInTriadFamily(int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInTriadFamilyAsync(int numberOfColors);

public Dictionary<GeoColor, Collection<GeoColor>> GetColorsInTriadFamily(GeoColor color, int numberOfColors);

public Task<Dictionary<GeoColor, Collection<GeoColor>>> GetColorsInTriadFamilyAsync(GeoColor color, int numberOfColors);

}

public class ElevationClient : BaseClient, IDisposable

{

public ElevationClient();

public ElevationClient(string clientId, string clientSecret);

public double GetElevationOfPoint(double x, double y, int pointProjectionInSrid, DistanceUnit elevationUnit);

public double GetElevationOfPoint(double x, double y, string pointProjectionInProj4String, DistanceUnit elevationUnit);

public Task<double> GetElevationOfPointAsync(double x, double y, int pointProjectionInSrid, DistanceUnit elevationUnit);

public Task<double> GetElevationOfPointAsync(double x, double y, string pointProjectionInProj4String, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfPoints(IEnumerable<PointShape> points, int pointsProjectionInSrid, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfPoints(IEnumerable<PointShape> points, string pointsProjectionInProj4String, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfPointsAsync(IEnumerable<PointShape> points, int pointsProjectionInSrid, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfPointsAsync(IEnumerable<PointShape> points, string pointsProjectionInProj4String, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfLine(LineBaseShape line, int lineProjectionInSrid, int numberOfSegments, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfLine(LineBaseShape line, string lineProjectionInProj4String, int numberOfSegments, DistanceUnit elevationUnit);¬

public ElevationResult GetElevationOfLine(LineBaseShape line, int lineProjectionInSrid, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfLine(LineBaseShape line, string lineProjectionInProj4String, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfLineAsync(LineBaseShape line, int lineProjectionInSrid, int numberOfSegments, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfLineAsync(LineBaseShape line, string lineProjectionInProj4String, int numberOfSegments, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfLineAsync(LineBaseShape line, int lineProjectionInSrid, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfLineAsync(LineBaseShape line, string lineProjectionInProj4String, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public GradeResult GetGradeOfLine(LineShape line, int lineProjectionInSrid, int numberOfSegments, DistanceUnit elevationUnit);

public GradeResult GetGradeOfLine(LineShape line, string lineProjectionInProj4String, int numberOfSegments, DistanceUnit elevationUnit);

public GradeResult GetGradeOfLine(LineShape line, int lineProjectionInSrid, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public GradeResult GetGradeOfLine(LineShape line, string lineProjectionInProj4String, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<GradeResult> GetGradeOfLineAsync(LineShape line, int lineProjectionInSrid, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<GradeResult> GetGradeOfLineAsync(LineShape line, string lineProjectionInProj4String, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<GradeResult> GetGradeOfLineAsync(LineShape line, int lineProjectionInSrid, int numberOfSegments, DistanceUnit elevationUnit);

public Task<GradeResult> GetGradeOfLineAsync(LineShape line, string lineProjectionInProj4String, int numberOfSegments, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfArea(AreaBaseShape area, int projectionInSrid, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public ElevationResult GetElevationOfArea(AreaBaseShape area, string projectionInProj4String, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfAreaAsync(AreaBaseShape area, int projectionInSrid, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

public Task<ElevationResult> GetElevationOfAreaAsync(AreaBaseShape area, string projectionInProj4String, double intervalDistance, DistanceUnit intervalDistanceUnit, DistanceUnit elevationUnit);

}

public struct ElevationPointResult //

{

public ElevationPointResult(double elevation, PointShape point, ThinkGeoCloudApplicationException exception);

public double Elevation { get; }

public PointShape Point { get; }

public ThinkGeoCloudApplicationException Exception { get; }

}

public class ElevationResult

{

public ElevationResult(Collection<ElevationPointResult> elevationPoints, ElevationPointResult highestElevationPoint, ElevationPointResult lowestElevationPoint, double averageElevation);

public Collection<ElevationPointResult> ElevationPoints { get; }

public ElevationPointResult LowestElevationPoint { get; }

public ElevationPointResult HighestElevationPoint { get; }

public double AverageElevation { get; }

}

public class GettingAccessTokenEventArgs : EventArgs

{

public GettingAccessTokenEventArgs();

public GettingAccessTokenEventArgs(WebRequest webRequest);

public GettingAccessTokenEventArgs(WebRequest webRequest, bool cancel);

public WebRequest WebRequest { get; }

public bool Cancel { get; set; }

}

public class GradeResult

{

public GradeResult(GradeSegment highestGradeSegment, GradeSegment lowestGradeSegment, double averageGrade);

public Collection<GradeSegment> GradeSegments { get; }

public GradeSegment HighestGradeSegment { get; }

public GradeSegment LowestGradeSegment { get; }

public double AverageGrade { get; }

}

public struct GradeSegment

{

public GradeSegment(double grade, LineShape gradeLine, double startingElevation, double endingElevation);

public double Grade { get; }

public LineShape GradeLine { get; }

public double StartingElevation { get; }

public double EndingElevation { get; }

}

[Flags]

public enum LocationCategories

{

None,

Common,

All,

Aeroway,

Amenity,

Barrier,

Boundary,

Building,

Education,

Entertainment,

Financial,

Healthcare,

Historic,

Leisure,

Manmade,

Natural,

Rail,

Power,

Road,

Shop,

Sport,

Sustenance,

Tourism,

Transportation,

Waterway,

Intersection,

AddressPoint,

Others,

}

public enum MapProjection

{

SphericalMercator,

}

public class MapsClient : BaseClient, IDisposable

{

public MapsClient();

public MapsClient(string clientId, string clientSecret);

public Stream GetRasterTile(long z, long x, long y, MapProjection projection, RasterMapType mapType, TileSize tileSize, TileResolution tileResolution);

public Task<Stream> GetRasterTileAsync(long z, long x, long y, MapProjection projection, RasterMapType mapType, TileSize tileSize, TileResolution tileResolution);

public Stream GetVectorTile(long z, long x, long y, MapProjection projection);

public Task<Stream> GetVectorTileAsync(long z, long x, long y, MapProjection projection);

}

public class ProjectionClient : BaseClient, IDisposable

{

public ProjectionClient();

public ProjectionClient(string clientId, string clientSecret);

public Feature Project(Feature feature, string fromProjectionInProj4String, string toProjectionInProj4String);

public Feature Project(Feature feature, int fromProjectionInSrid, int toProjectionInSrid);

public Feature Project(Feature feature, string fromProjectionInProj4String, int toProjectionInSrid);

public Feature Project(Feature feature, int fromProjectionInSrid, string toProjectionInProj4String);

public Task<Feature> ProjectAsync(Feature feature, string fromProjectionInProj4String, string toProjectionInProj4String);

public Task<Feature> ProjectAsync(Feature feature, int fromProjectionInSrid, int toProjectionInSrid);

public Task<Feature> ProjectAsync(Feature feature, string fromProjectionInProj4String, int toProjectionInSrid);

public Task<Feature> ProjectAsync(Feature feature, int fromProjectionInSrid, string toProjectionInProj4String);

}

public enum RasterMapType

{

Default,

Light,

Dark,

Hybrid,

Aerial,

TransparentBackground,

}

public class ReverseGeocodingClient : BaseClient, IDisposable

{

public ReverseGeocodingClient();

public ReverseGeocodingClient(string clientId, string clientSecret);

public ReverseGeocodingResult Search(double x, double y, int pointProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius);

public ReverseGeocodingResult Search(double x, double y, int pointProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public ReverseGeocodingResult Search(double x, double y, string pointProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius);

public ReverseGeocodingResult Search(double x, double y, string pointProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public Task<ReverseGeocodingResult> SearchAsync(double x, double y, int pointProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius);

public Task<ReverseGeocodingResult> SearchAsync(double x, double y, int pointProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public Task<ReverseGeocodingResult> SearchAsync(double x, double y, string pointProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius);

public Task<ReverseGeocodingResult> SearchAsync(double x, double y, string pointProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public ReverseGeocodingResult Search(LineShape line, int lineProjectionInSrid, double searchBuffer, DistanceUnit unitOfsearchBuffer);

public ReverseGeocodingResult Search(LineShape line, int lineProjectionInSrid, double searchBuffer, DistanceUnit unitOfsearchBuffer, ReverseGeocodingOptions options);

public ReverseGeocodingResult Search(LineShape line, string lineProjectionInProj4String, double searchBuffer, DistanceUnit unitOfsearchBuffer);

public ReverseGeocodingResult Search(LineShape line, string lineProjectionInProj4String, double searchBuffer, DistanceUnit unitOfsearchBuffer, ReverseGeocodingOptions options);

public Task<ReverseGeocodingResult> SearchAsync(LineShape line, int lineProjectionInSrid, double searchBuffer, DistanceUnit unitOfsearchBuffer);

public Task<ReverseGeocodingResult> SearchAsync(LineShape line, int lineProjectionInSrid, double searchBuffer, DistanceUnit unitOfsearchBuffer, ReverseGeocodingOptions options);

public Task<ReverseGeocodingResult> SearchAsync(LineShape line, string lineProjectionInProj4String, double searchBuffer, DistanceUnit unitOfsearchBuffer);

public Task<ReverseGeocodingResult> SearchAsync(LineShape line, string lineProjectionInProj4String, double searchBuffer, DistanceUnit unitOfsearchBuffer, ReverseGeocodingOptions options);

public ReverseGeocodingResult Search(PolygonShape area, int areaProjectionInSrid);

public ReverseGeocodingResult Search(PolygonShape area, int areaProjectionInSrid, ReverseGeocodingOptions options);

public ReverseGeocodingResult Search(PolygonShape area, string areaProjectionInProj4String);

public ReverseGeocodingResult Search(PolygonShape area, string areaProjectionInProj4String, ReverseGeocodingOptions options);

public Task<ReverseGeocodingResult> SearchAsync(PolygonShape area, int areaProjectionInSrid);

public Task<ReverseGeocodingResult> SearchAsync(PolygonShape area, int areaProjectionInSrid, ReverseGeocodingOptions options);

public Task<ReverseGeocodingResult> SearchAsync(PolygonShape area, string areaProjectionInProj4String);

public Task<ReverseGeocodingResult> SearchAsync(PolygonShape area, string areaProjectionInProj4String, ReverseGeocodingOptions options);

public Collection<ReverseGeocodingResult> Search(IEnumerable<PointShape> points, int pointsProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius);

public Collection<ReverseGeocodingResult> Search(IEnumerable<PointShape> points, int pointsProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public Collection<ReverseGeocodingResult> Search(IEnumerable<PointShape> points, string pointsProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius);

public Collection<ReverseGeocodingResult> Search(IEnumerable<PointShape> points, string pointsProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public Task<Collection<ReverseGeocodingResult>> SearchAsync(IEnumerable<PointShape> points, int pointsProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius);

public Task<Collection<ReverseGeocodingResult>> SearchAsync(IEnumerable<PointShape> points, int pointsProjectionInSrid, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

public Task<Collection<ReverseGeocodingResult>> SearchAsync(IEnumerable<PointShape> points, string pointsProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius);

public Task<Collection<ReverseGeocodingResult>> SearchAsync(IEnumerable<PointShape> points, string pointsProjectionInProj4String, double searchRadius, DistanceUnit unitOfsearchRadius, ReverseGeocodingOptions options);

}

public class ReverseGeocodingLocation

{

public ReverseGeocodingLocation();

public Feature LocationFeature { get; set; }

public string LocationName { get; set; }

public string RelationToQueryFeature { get; set; }

public string DirectionFromQueryFeature { get; set; }

public double DistanceFromQueryFeature { get; set; }

public string LocationCategory { get; set; }

public string LocationType { get; set; }

public string Address { get; set; }

public string HouseNumber { get; set; }

public Dictionary<string, string> Properties { get; set; }

public string Postcode { get; set; }

public Dictionary<string, string> AddressComponents { get; set; }//key 唯一

}

public class ReverseGeocodingOptions

{

public ReverseGeocodingOptions();

public int MaxResults { get; set; }

public LocationCategories LocationCategories { get; set; }

public ReverseGeocodingResultDetail ResultDetail { get; set; }

public DistanceUnit DistanceUnit { get; set; }

public Collection<string> LocationTypes { get; }

}

public class ReverseGeocodingResult

{

public ReverseGeocodingResult(Feature queryFeature, ReverseGeocodingLocation bestMatchLocation, ThinkGeoCloudApplicationException exception);

public Feature QueryFeature { get; }

public ReverseGeocodingLocation BestMatchLocation { get; }

public Collection<ReverseGeocodingLocation> NearbyLocations { get; }

public ThinkGeoCloudApplicationException Exception { get; }

}

public enum ReverseGeocodingResultDetail

{

Default,

Verbose,

Standard,

}

public class ThinkGeoCloudApplicationException : ApplicationException, ISerializable, _Exception

{

public ThinkGeoCloudApplicationException(HttpStatusCode statusCode, string message, Exception innerException);

public HttpStatusCode StatusCode { get; }

}

public enum TileResolution

{

Default,

Standard,

High,

}

public enum TileSize

{

Default,

Small,

Medium,

}