~ubuntu-branches/debian/stretch/golang-github-aws-aws-sdk-go/stretch

func (c *Route53) AssociateVPCWithHostedZoneRequest(input *AssociateVPCWithHostedZoneInput) (req *request.Request, output *AssociateVPCWithHostedZoneOutput) {

op := &request.Operation{

Name: opAssociateVPCWithHostedZone,

HTTPMethod: "POST",

HTTPPath: "/2013-04-01/hostedzone/{Id}/associatevpc",

}

if input == nil {

input = &AssociateVPCWithHostedZoneInput{}

}

req = c.newRequest(op, input, output)

output = &AssociateVPCWithHostedZoneOutput{}

req.Data = output

return

}

// This action associates a VPC with an hosted zone.

// To associate a VPC with an hosted zone, send a POST request to the 2013-04-01/hostedzone/hosted

// zone ID/associatevpc resource. The request body must include an XML document

// with a AssociateVPCWithHostedZoneRequest element. The response returns the

// AssociateVPCWithHostedZoneResponse element that contains ChangeInfo for you

// to track the progress of the AssociateVPCWithHostedZoneRequest you made.

// See GetChange operation for how to track the progress of your change.

func (c *Route53) AssociateVPCWithHostedZone(input *AssociateVPCWithHostedZoneInput) (*AssociateVPCWithHostedZoneOutput, error) {

req, out := c.AssociateVPCWithHostedZoneRequest(input)

err := req.Send()

return out, err

}

const opChangeResourceRecordSets = "ChangeResourceRecordSets"

// ChangeResourceRecordSetsRequest generates a request for the ChangeResourceRecordSets operation.

func (c *Route53) ChangeResourceRecordSetsRequest(input *ChangeResourceRecordSetsInput) (req *request.Request, output *ChangeResourceRecordSetsOutput) {

op := &request.Operation{

Name: opChangeResourceRecordSets,

HTTPMethod: "POST",

HTTPPath: "/2013-04-01/hostedzone/{Id}/rrset/",

}

if input == nil {

input = &ChangeResourceRecordSetsInput{}

}

req = c.newRequest(op, input, output)

output = &ChangeResourceRecordSetsOutput{}

req.Data = output

return

}

// Use this action to create or change your authoritative DNS information. To

// use this action, send a POST request to the 2013-04-01/hostedzone/hosted

// Zone ID/rrset resource. The request body must include an XML document with

// a ChangeResourceRecordSetsRequest element.

// Changes are a list of change items and are considered transactional. For

// more information on transactional changes, also known as change batches,

// see Creating, Changing, and Deleting Resource Record Sets Using the Route

// 53 API (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/RRSchanges.html#RRSchanges_API)

// in the Amazon Route 53 Developer Guide.

// Due to the nature of transactional changes, you cannot delete the same resource

// record set more than once in a single change batch. If you attempt to delete

// the same change batch more than once, Route 53 returns an InvalidChangeBatch

// error. In response to a ChangeResourceRecordSets request, your DNS data is

// changed on all Route 53 DNS servers. Initially, the status of a change is

// PENDING. This means the change has not yet propagated to all the authoritative

// Route 53 DNS servers. When the change is propagated to all hosts, the change

// returns a status of INSYNC.

// Note the following limitations on a ChangeResourceRecordSets request:

// - A request cannot contain more than 100 Change elements.

// - A request cannot contain more than 1000 ResourceRecord elements.

// The sum of the number of characters (including spaces) in all Value elements

// in a request cannot exceed 32,000 characters.

func (c *Route53) ChangeResourceRecordSets(input *ChangeResourceRecordSetsInput) (*ChangeResourceRecordSetsOutput, error) {

req, out := c.ChangeResourceRecordSetsRequest(input)

err := req.Send()

return out, err

}

100

101

const opChangeTagsForResource = "ChangeTagsForResource"

102

103

// ChangeTagsForResourceRequest generates a request for the ChangeTagsForResource operation.

104

func (c *Route53) ChangeTagsForResourceRequest(input *ChangeTagsForResourceInput) (req *request.Request, output *ChangeTagsForResourceOutput) {

105

op := &request.Operation{

106

Name: opChangeTagsForResource,

107

HTTPMethod: "POST",

108

HTTPPath: "/2013-04-01/tags/{ResourceType}/{ResourceId}",

109

}

110

111

if input == nil {

112

input = &ChangeTagsForResourceInput{}

113

}

114

115

req = c.newRequest(op, input, output)

116

output = &ChangeTagsForResourceOutput{}

117

req.Data = output

118

return

119

}

120

121

func (c *Route53) ChangeTagsForResource(input *ChangeTagsForResourceInput) (*ChangeTagsForResourceOutput, error) {

122

req, out := c.ChangeTagsForResourceRequest(input)

123

err := req.Send()

124

return out, err

125

}

126

127

const opCreateHealthCheck = "CreateHealthCheck"

128

129

// CreateHealthCheckRequest generates a request for the CreateHealthCheck operation.

130

func (c *Route53) CreateHealthCheckRequest(input *CreateHealthCheckInput) (req *request.Request, output *CreateHealthCheckOutput) {

131

op := &request.Operation{

132

Name: opCreateHealthCheck,

133

HTTPMethod: "POST",

134

HTTPPath: "/2013-04-01/healthcheck",

135

}

136

137

if input == nil {

138

input = &CreateHealthCheckInput{}

139

}

140

141

req = c.newRequest(op, input, output)

142

output = &CreateHealthCheckOutput{}

143

req.Data = output

144

return

145

}

146

147

// This action creates a new health check.

148

149

// To create a new health check, send a POST request to the 2013-04-01/healthcheck

150

// resource. The request body must include an XML document with a CreateHealthCheckRequest

151

// element. The response returns the CreateHealthCheckResponse element that

152

// contains metadata about the health check.

153

func (c *Route53) CreateHealthCheck(input *CreateHealthCheckInput) (*CreateHealthCheckOutput, error) {

154

req, out := c.CreateHealthCheckRequest(input)

155

err := req.Send()

156

return out, err

157

}

158

159

const opCreateHostedZone = "CreateHostedZone"

160

161

// CreateHostedZoneRequest generates a request for the CreateHostedZone operation.

162

func (c *Route53) CreateHostedZoneRequest(input *CreateHostedZoneInput) (req *request.Request, output *CreateHostedZoneOutput) {

163

op := &request.Operation{

164

Name: opCreateHostedZone,

165

HTTPMethod: "POST",

166

HTTPPath: "/2013-04-01/hostedzone",

167

}

168

169

if input == nil {

170

input = &CreateHostedZoneInput{}

171

}

172

173

req = c.newRequest(op, input, output)

174

output = &CreateHostedZoneOutput{}

175

req.Data = output

176

return

177

}

178

179

// This action creates a new hosted zone.

180

181

// To create a new hosted zone, send a POST request to the 2013-04-01/hostedzone

182

// resource. The request body must include an XML document with a CreateHostedZoneRequest

183

// element. The response returns the CreateHostedZoneResponse element that contains

184

// metadata about the hosted zone.

185

186

// Route 53 automatically creates a default SOA record and four NS records

187

// for the zone. The NS records in the hosted zone are the name servers you

188

// give your registrar to delegate your domain to. For more information about

189

// SOA and NS records, see NS and SOA Records that Route 53 Creates for a Hosted

190

// Zone (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/SOA-NSrecords.html)

191

// in the Amazon Route 53 Developer Guide.

192

193

// When you create a zone, its initial status is PENDING. This means that it

194

// is not yet available on all DNS servers. The status of the zone changes to

195

// INSYNC when the NS and SOA records are available on all Route 53 DNS servers.

196

197

// When trying to create a hosted zone using a reusable delegation set, you

198

// could specify an optional DelegationSetId, and Route53 would assign those

199

// 4 NS records for the zone, instead of alloting a new one.

200

func (c *Route53) CreateHostedZone(input *CreateHostedZoneInput) (*CreateHostedZoneOutput, error) {

201

req, out := c.CreateHostedZoneRequest(input)

202

err := req.Send()

203

return out, err

204

}

205

206

const opCreateReusableDelegationSet = "CreateReusableDelegationSet"

207

208

// CreateReusableDelegationSetRequest generates a request for the CreateReusableDelegationSet operation.

209

func (c *Route53) CreateReusableDelegationSetRequest(input *CreateReusableDelegationSetInput) (req *request.Request, output *CreateReusableDelegationSetOutput) {

210

op := &request.Operation{

211

Name: opCreateReusableDelegationSet,

212

HTTPMethod: "POST",

213

HTTPPath: "/2013-04-01/delegationset",

214

}

215

216

if input == nil {

217

input = &CreateReusableDelegationSetInput{}

218

}

219

220

req = c.newRequest(op, input, output)

221

output = &CreateReusableDelegationSetOutput{}

222

req.Data = output

223

return

224

}

225

226

// This action creates a reusable delegationSet.

227

228

// To create a new reusable delegationSet, send a POST request to the 2013-04-01/delegationset

229

// resource. The request body must include an XML document with a CreateReusableDelegationSetRequest

230

// element. The response returns the CreateReusableDelegationSetResponse element

231

// that contains metadata about the delegationSet.

232

233

// If the optional parameter HostedZoneId is specified, it marks the delegationSet

234

// associated with that particular hosted zone as reusable.

235

func (c *Route53) CreateReusableDelegationSet(input *CreateReusableDelegationSetInput) (*CreateReusableDelegationSetOutput, error) {

236

req, out := c.CreateReusableDelegationSetRequest(input)

237

err := req.Send()

238

return out, err

239

}

240

241

const opDeleteHealthCheck = "DeleteHealthCheck"

242

243

// DeleteHealthCheckRequest generates a request for the DeleteHealthCheck operation.

244

func (c *Route53) DeleteHealthCheckRequest(input *DeleteHealthCheckInput) (req *request.Request, output *DeleteHealthCheckOutput) {

245

op := &request.Operation{

246

Name: opDeleteHealthCheck,

247

HTTPMethod: "DELETE",

248

HTTPPath: "/2013-04-01/healthcheck/{HealthCheckId}",

249

}

250

251

if input == nil {

252

input = &DeleteHealthCheckInput{}

253

}

254

255

req = c.newRequest(op, input, output)

256

output = &DeleteHealthCheckOutput{}

257

req.Data = output

258

return

259

}

260

261

// This action deletes a health check. To delete a health check, send a DELETE

262

// request to the 2013-04-01/healthcheck/health check ID resource.

263

264

// You can delete a health check only if there are no resource record sets

265

// associated with this health check. If resource record sets are associated

266

// with this health check, you must disassociate them before you can delete

267

// your health check. If you try to delete a health check that is associated

268

// with resource record sets, Route 53 will deny your request with a HealthCheckInUse

269

// error. For information about disassociating the records from your health

270

// check, see ChangeResourceRecordSets.

271

func (c *Route53) DeleteHealthCheck(input *DeleteHealthCheckInput) (*DeleteHealthCheckOutput, error) {

272

req, out := c.DeleteHealthCheckRequest(input)

273

err := req.Send()

274

return out, err

275

}

276

277

const opDeleteHostedZone = "DeleteHostedZone"

278

279

// DeleteHostedZoneRequest generates a request for the DeleteHostedZone operation.

280

func (c *Route53) DeleteHostedZoneRequest(input *DeleteHostedZoneInput) (req *request.Request, output *DeleteHostedZoneOutput) {

281

op := &request.Operation{

282

Name: opDeleteHostedZone,

283

HTTPMethod: "DELETE",

284

HTTPPath: "/2013-04-01/hostedzone/{Id}",

285

}

286

287

if input == nil {

288

input = &DeleteHostedZoneInput{}

289

}

290

291

req = c.newRequest(op, input, output)

292

output = &DeleteHostedZoneOutput{}

293

req.Data = output

294

return

295

}

296

297

// This action deletes a hosted zone. To delete a hosted zone, send a DELETE

298

// request to the 2013-04-01/hostedzone/hosted zone ID resource.

299

300

// For more information about deleting a hosted zone, see Deleting a Hosted

301

// Zone (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DeleteHostedZone.html)

302

// in the Amazon Route 53 Developer Guide.

303

304

// You can delete a hosted zone only if there are no resource record sets

305

// other than the default SOA record and NS resource record sets. If your hosted

306

// zone contains other resource record sets, you must delete them before you

307

// can delete your hosted zone. If you try to delete a hosted zone that contains

308

// other resource record sets, Route 53 will deny your request with a HostedZoneNotEmpty

309

// error. For information about deleting records from your hosted zone, see

310

// ChangeResourceRecordSets.

311

func (c *Route53) DeleteHostedZone(input *DeleteHostedZoneInput) (*DeleteHostedZoneOutput, error) {

312

req, out := c.DeleteHostedZoneRequest(input)

313

err := req.Send()

314

return out, err

315

}

316

317

const opDeleteReusableDelegationSet = "DeleteReusableDelegationSet"

318

319

// DeleteReusableDelegationSetRequest generates a request for the DeleteReusableDelegationSet operation.

320

func (c *Route53) DeleteReusableDelegationSetRequest(input *DeleteReusableDelegationSetInput) (req *request.Request, output *DeleteReusableDelegationSetOutput) {

321

op := &request.Operation{

322

Name: opDeleteReusableDelegationSet,

323

HTTPMethod: "DELETE",

324

HTTPPath: "/2013-04-01/delegationset/{Id}",

325

}

326

327

if input == nil {

328

input = &DeleteReusableDelegationSetInput{}

329

}

330

331

req = c.newRequest(op, input, output)

332

output = &DeleteReusableDelegationSetOutput{}

333

req.Data = output

334

return

335

}

336

337

// This action deletes a reusable delegation set. To delete a reusable delegation

338

// set, send a DELETE request to the 2013-04-01/delegationset/delegation set

339

// ID resource.

340

341

// You can delete a reusable delegation set only if there are no associated

342

// hosted zones. If your reusable delegation set contains associated hosted

343

// zones, you must delete them before you can delete your reusable delegation

344

// set. If you try to delete a reusable delegation set that contains associated

345

// hosted zones, Route 53 will deny your request with a DelegationSetInUse error.

346

func (c *Route53) DeleteReusableDelegationSet(input *DeleteReusableDelegationSetInput) (*DeleteReusableDelegationSetOutput, error) {

347

req, out := c.DeleteReusableDelegationSetRequest(input)

348

err := req.Send()

349

return out, err

350

}

351

352

const opDisassociateVPCFromHostedZone = "DisassociateVPCFromHostedZone"

353

354

// DisassociateVPCFromHostedZoneRequest generates a request for the DisassociateVPCFromHostedZone operation.

355

func (c *Route53) DisassociateVPCFromHostedZoneRequest(input *DisassociateVPCFromHostedZoneInput) (req *request.Request, output *DisassociateVPCFromHostedZoneOutput) {

356

op := &request.Operation{

357

Name: opDisassociateVPCFromHostedZone,

358

HTTPMethod: "POST",

359

HTTPPath: "/2013-04-01/hostedzone/{Id}/disassociatevpc",

360

}

361

362

if input == nil {

363

input = &DisassociateVPCFromHostedZoneInput{}

364

}

365

366

req = c.newRequest(op, input, output)

367

output = &DisassociateVPCFromHostedZoneOutput{}

368

req.Data = output

369

return

370

}

371

372

// This action disassociates a VPC from an hosted zone.

373

374

// To disassociate a VPC to a hosted zone, send a POST request to the 2013-04-01/hostedzone/hosted

375

// zone ID/disassociatevpc resource. The request body must include an XML document

376

// with a DisassociateVPCFromHostedZoneRequest element. The response returns

377

// the DisassociateVPCFromHostedZoneResponse element that contains ChangeInfo

378

// for you to track the progress of the DisassociateVPCFromHostedZoneRequest

379

// you made. See GetChange operation for how to track the progress of your change.

380

func (c *Route53) DisassociateVPCFromHostedZone(input *DisassociateVPCFromHostedZoneInput) (*DisassociateVPCFromHostedZoneOutput, error) {

381

req, out := c.DisassociateVPCFromHostedZoneRequest(input)

382

err := req.Send()

383

return out, err

384

}

385

386

const opGetChange = "GetChange"

387

388

// GetChangeRequest generates a request for the GetChange operation.

389

func (c *Route53) GetChangeRequest(input *GetChangeInput) (req *request.Request, output *GetChangeOutput) {

390

op := &request.Operation{

391

Name: opGetChange,

392

HTTPMethod: "GET",

393

HTTPPath: "/2013-04-01/change/{Id}",

394

}

395

396

if input == nil {

397

input = &GetChangeInput{}

398

}

399

400

req = c.newRequest(op, input, output)

401

output = &GetChangeOutput{}

402

req.Data = output

403

return

404

}

405

406

// This action returns the current status of a change batch request. The status

407

// is one of the following values:

408

409

// - PENDING indicates that the changes in this request have not replicated

410

// to all Route 53 DNS servers. This is the initial status of all change batch

411

// requests.

412

413

// - INSYNC indicates that the changes have replicated to all Amazon Route

414

// 53 DNS servers.

415

func (c *Route53) GetChange(input *GetChangeInput) (*GetChangeOutput, error) {

416

req, out := c.GetChangeRequest(input)

417

err := req.Send()

418

return out, err

419

}

420

421

const opGetCheckerIpRanges = "GetCheckerIpRanges"

422

423

// GetCheckerIpRangesRequest generates a request for the GetCheckerIpRanges operation.

424

func (c *Route53) GetCheckerIpRangesRequest(input *GetCheckerIpRangesInput) (req *request.Request, output *GetCheckerIpRangesOutput) {

425

op := &request.Operation{

426

Name: opGetCheckerIpRanges,

427

HTTPMethod: "GET",

428

HTTPPath: "/2013-04-01/checkeripranges",

429

}

430

431

if input == nil {

432

input = &GetCheckerIpRangesInput{}

433

}

434

435

req = c.newRequest(op, input, output)

436

output = &GetCheckerIpRangesOutput{}

437

req.Data = output

438

return

439

}

440

441

// To retrieve a list of the IP ranges used by Amazon Route 53 health checkers

442

// to check the health of your resources, send a GET request to the 2013-04-01/checkeripranges

443

// resource. You can use these IP addresses to configure router and firewall

444

// rules to allow health checkers to check the health of your resources.

445

func (c *Route53) GetCheckerIpRanges(input *GetCheckerIpRangesInput) (*GetCheckerIpRangesOutput, error) {

446

req, out := c.GetCheckerIpRangesRequest(input)

447

err := req.Send()

448

return out, err

449

}

450

451

const opGetGeoLocation = "GetGeoLocation"

452

453

// GetGeoLocationRequest generates a request for the GetGeoLocation operation.

454

func (c *Route53) GetGeoLocationRequest(input *GetGeoLocationInput) (req *request.Request, output *GetGeoLocationOutput) {

455

op := &request.Operation{

456

Name: opGetGeoLocation,

457

HTTPMethod: "GET",

458

HTTPPath: "/2013-04-01/geolocation",

459

}

460

461

if input == nil {

462

input = &GetGeoLocationInput{}

463

}

464

465

req = c.newRequest(op, input, output)

466

output = &GetGeoLocationOutput{}

467

req.Data = output

468

return

469

}

470

471

// To retrieve a single geo location, send a GET request to the 2013-04-01/geolocation

472

// resource with one of these options: continentcode | countrycode | countrycode

473

// and subdivisioncode.

474

func (c *Route53) GetGeoLocation(input *GetGeoLocationInput) (*GetGeoLocationOutput, error) {

475

req, out := c.GetGeoLocationRequest(input)

476

err := req.Send()

477

return out, err

478

}

479

480

const opGetHealthCheck = "GetHealthCheck"

481

482

// GetHealthCheckRequest generates a request for the GetHealthCheck operation.

483

func (c *Route53) GetHealthCheckRequest(input *GetHealthCheckInput) (req *request.Request, output *GetHealthCheckOutput) {

484

op := &request.Operation{

485

Name: opGetHealthCheck,

486

HTTPMethod: "GET",

487

HTTPPath: "/2013-04-01/healthcheck/{HealthCheckId}",

488

}

489

490

if input == nil {

491

input = &GetHealthCheckInput{}

492

}

493

494

req = c.newRequest(op, input, output)

495

output = &GetHealthCheckOutput{}

496

req.Data = output

497

return

498

}

499

500

// To retrieve the health check, send a GET request to the 2013-04-01/healthcheck/health

501

// check ID resource.

502

func (c *Route53) GetHealthCheck(input *GetHealthCheckInput) (*GetHealthCheckOutput, error) {

503

req, out := c.GetHealthCheckRequest(input)

504

err := req.Send()

505

return out, err

506

}

507

508

const opGetHealthCheckCount = "GetHealthCheckCount"

509

510

// GetHealthCheckCountRequest generates a request for the GetHealthCheckCount operation.

511

func (c *Route53) GetHealthCheckCountRequest(input *GetHealthCheckCountInput) (req *request.Request, output *GetHealthCheckCountOutput) {

512

op := &request.Operation{

513

Name: opGetHealthCheckCount,

514

HTTPMethod: "GET",

515

HTTPPath: "/2013-04-01/healthcheckcount",

516

}

517

518

if input == nil {

519

input = &GetHealthCheckCountInput{}

520

}

521

522

req = c.newRequest(op, input, output)

523

output = &GetHealthCheckCountOutput{}

524

req.Data = output

525

return

526

}

527

528

// To retrieve a count of all your health checks, send a GET request to the

529

// 2013-04-01/healthcheckcount resource.

530

func (c *Route53) GetHealthCheckCount(input *GetHealthCheckCountInput) (*GetHealthCheckCountOutput, error) {

531

req, out := c.GetHealthCheckCountRequest(input)

532

err := req.Send()

533

return out, err

534

}

535

536

const opGetHealthCheckLastFailureReason = "GetHealthCheckLastFailureReason"

537

538

// GetHealthCheckLastFailureReasonRequest generates a request for the GetHealthCheckLastFailureReason operation.

539

func (c *Route53) GetHealthCheckLastFailureReasonRequest(input *GetHealthCheckLastFailureReasonInput) (req *request.Request, output *GetHealthCheckLastFailureReasonOutput) {

540

op := &request.Operation{

541

Name: opGetHealthCheckLastFailureReason,

542

HTTPMethod: "GET",

543

HTTPPath: "/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason",

544

}

545

546

if input == nil {

547

input = &GetHealthCheckLastFailureReasonInput{}

548

}

549

550

req = c.newRequest(op, input, output)

551

output = &GetHealthCheckLastFailureReasonOutput{}

552

req.Data = output

553

return

554

}

555

556

// If you want to learn why a health check is currently failing or why it failed

557

// most recently (if at all), you can get the failure reason for the most recent

558

// failure. Send a GET request to the 2013-04-01/healthcheck/health check ID/lastfailurereason

559

// resource.

560

func (c *Route53) GetHealthCheckLastFailureReason(input *GetHealthCheckLastFailureReasonInput) (*GetHealthCheckLastFailureReasonOutput, error) {

561

req, out := c.GetHealthCheckLastFailureReasonRequest(input)

562

err := req.Send()

563

return out, err

564

}

565

566

const opGetHealthCheckStatus = "GetHealthCheckStatus"

567

568

// GetHealthCheckStatusRequest generates a request for the GetHealthCheckStatus operation.

569

func (c *Route53) GetHealthCheckStatusRequest(input *GetHealthCheckStatusInput) (req *request.Request, output *GetHealthCheckStatusOutput) {

570

op := &request.Operation{

571

Name: opGetHealthCheckStatus,

572

HTTPMethod: "GET",

573

HTTPPath: "/2013-04-01/healthcheck/{HealthCheckId}/status",

574

}

575

576

if input == nil {

577

input = &GetHealthCheckStatusInput{}

578

}

579

580

req = c.newRequest(op, input, output)

581

output = &GetHealthCheckStatusOutput{}

582

req.Data = output

583

return

584

}

585

586

// To retrieve the health check status, send a GET request to the 2013-04-01/healthcheck/health

587

// check ID/status resource. You can use this call to get a health check's current

588

// status.

589

func (c *Route53) GetHealthCheckStatus(input *GetHealthCheckStatusInput) (*GetHealthCheckStatusOutput, error) {

590

req, out := c.GetHealthCheckStatusRequest(input)

591

err := req.Send()

592

return out, err

593

}

594

595

const opGetHostedZone = "GetHostedZone"

596

597

// GetHostedZoneRequest generates a request for the GetHostedZone operation.

598

func (c *Route53) GetHostedZoneRequest(input *GetHostedZoneInput) (req *request.Request, output *GetHostedZoneOutput) {

599

op := &request.Operation{

600

Name: opGetHostedZone,

601

HTTPMethod: "GET",

602

HTTPPath: "/2013-04-01/hostedzone/{Id}",

603

}

604

605

if input == nil {

606

input = &GetHostedZoneInput{}

607

}

608

609

req = c.newRequest(op, input, output)

610

output = &GetHostedZoneOutput{}

611

req.Data = output

612

return

613

}

614

615

// To retrieve the delegation set for a hosted zone, send a GET request to the

616

// 2013-04-01/hostedzone/hosted zone ID resource. The delegation set is the

617

// four Route 53 name servers that were assigned to the hosted zone when you

618

// created it.

619

func (c *Route53) GetHostedZone(input *GetHostedZoneInput) (*GetHostedZoneOutput, error) {

620

req, out := c.GetHostedZoneRequest(input)

621

err := req.Send()

622

return out, err

623

}

624

625

const opGetHostedZoneCount = "GetHostedZoneCount"

626

627

// GetHostedZoneCountRequest generates a request for the GetHostedZoneCount operation.

628

func (c *Route53) GetHostedZoneCountRequest(input *GetHostedZoneCountInput) (req *request.Request, output *GetHostedZoneCountOutput) {

629

op := &request.Operation{

630

Name: opGetHostedZoneCount,

631

HTTPMethod: "GET",

632

HTTPPath: "/2013-04-01/hostedzonecount",

633

}

634

635

if input == nil {

636

input = &GetHostedZoneCountInput{}

637

}

638

639

req = c.newRequest(op, input, output)

640

output = &GetHostedZoneCountOutput{}

641

req.Data = output

642

return

643

}

644

645

// To retrieve a count of all your hosted zones, send a GET request to the 2013-04-01/hostedzonecount

646

// resource.

647

func (c *Route53) GetHostedZoneCount(input *GetHostedZoneCountInput) (*GetHostedZoneCountOutput, error) {

648

req, out := c.GetHostedZoneCountRequest(input)

649

err := req.Send()

650

return out, err

651

}

652

653

const opGetReusableDelegationSet = "GetReusableDelegationSet"

654

655

// GetReusableDelegationSetRequest generates a request for the GetReusableDelegationSet operation.

656

func (c *Route53) GetReusableDelegationSetRequest(input *GetReusableDelegationSetInput) (req *request.Request, output *GetReusableDelegationSetOutput) {

657

op := &request.Operation{

658

Name: opGetReusableDelegationSet,

659

HTTPMethod: "GET",

660

HTTPPath: "/2013-04-01/delegationset/{Id}",

661

}

662

663

if input == nil {

664

input = &GetReusableDelegationSetInput{}

665

}

666

667

req = c.newRequest(op, input, output)

668

output = &GetReusableDelegationSetOutput{}

669

req.Data = output

670

return

671

}

672

673

// To retrieve the reusable delegation set, send a GET request to the 2013-04-01/delegationset/delegation

674

// set ID resource.

675

func (c *Route53) GetReusableDelegationSet(input *GetReusableDelegationSetInput) (*GetReusableDelegationSetOutput, error) {

676

req, out := c.GetReusableDelegationSetRequest(input)

677

err := req.Send()

678

return out, err

679

}

680

681

const opListGeoLocations = "ListGeoLocations"

682

683

// ListGeoLocationsRequest generates a request for the ListGeoLocations operation.

684

func (c *Route53) ListGeoLocationsRequest(input *ListGeoLocationsInput) (req *request.Request, output *ListGeoLocationsOutput) {

685

op := &request.Operation{

686

Name: opListGeoLocations,

687

HTTPMethod: "GET",

688

HTTPPath: "/2013-04-01/geolocations",

689

}

690

691

if input == nil {

692

input = &ListGeoLocationsInput{}

693

}

694

695

req = c.newRequest(op, input, output)

696

output = &ListGeoLocationsOutput{}

697

req.Data = output

698

return

699

}

700

701

// To retrieve a list of supported geo locations, send a GET request to the

702

// 2013-04-01/geolocations resource. The response to this request includes a

703

// GeoLocationDetailsList element with zero, one, or multiple GeoLocationDetails

704

// child elements. The list is sorted by country code, and then subdivision

705

// code, followed by continents at the end of the list.

706

707

// By default, the list of geo locations is displayed on a single page. You

708

// can control the length of the page that is displayed by using the MaxItems

709

// parameter. If the list is truncated, IsTruncated will be set to true and

710

// a combination of NextContinentCode, NextCountryCode, NextSubdivisionCode

711

// will be populated. You can pass these as parameters to StartContinentCode,

712

// StartCountryCode, StartSubdivisionCode to control the geo location that the

713

// list begins with.

714

func (c *Route53) ListGeoLocations(input *ListGeoLocationsInput) (*ListGeoLocationsOutput, error) {

715

req, out := c.ListGeoLocationsRequest(input)

716

err := req.Send()

717

return out, err

718

}

719

720

const opListHealthChecks = "ListHealthChecks"

721

722

// ListHealthChecksRequest generates a request for the ListHealthChecks operation.

723

func (c *Route53) ListHealthChecksRequest(input *ListHealthChecksInput) (req *request.Request, output *ListHealthChecksOutput) {

724

op := &request.Operation{

725

Name: opListHealthChecks,

726

HTTPMethod: "GET",

727

HTTPPath: "/2013-04-01/healthcheck",

728

Paginator: &request.Paginator{

729

InputTokens: []string{"Marker"},

730

OutputTokens: []string{"NextMarker"},

731

LimitToken: "MaxItems",

732

TruncationToken: "IsTruncated",

733

734

}

735

736

if input == nil {

737

input = &ListHealthChecksInput{}

738

}

739

740

req = c.newRequest(op, input, output)

741

output = &ListHealthChecksOutput{}

742

req.Data = output

743

return

744

}

745

746

// To retrieve a list of your health checks, send a GET request to the 2013-04-01/healthcheck

747

// resource. The response to this request includes a HealthChecks element with

748

// zero, one, or multiple HealthCheck child elements. By default, the list of

749

// health checks is displayed on a single page. You can control the length of

750

// the page that is displayed by using the MaxItems parameter. You can use the

751

// Marker parameter to control the health check that the list begins with.

752

753

// Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to

754

// a value greater than 100, Amazon Route 53 returns only the first 100.

755

func (c *Route53) ListHealthChecks(input *ListHealthChecksInput) (*ListHealthChecksOutput, error) {

756

req, out := c.ListHealthChecksRequest(input)

757

err := req.Send()

758

return out, err

759

}

760

761

func (c *Route53) ListHealthChecksPages(input *ListHealthChecksInput, fn func(p *ListHealthChecksOutput, lastPage bool) (shouldContinue bool)) error {

762

page, _ := c.ListHealthChecksRequest(input)

763

return page.EachPage(func(p interface{}, lastPage bool) bool {

764

return fn(p.(*ListHealthChecksOutput), lastPage)

765

})

766

}

767

768

const opListHostedZones = "ListHostedZones"

769

770

// ListHostedZonesRequest generates a request for the ListHostedZones operation.

771

func (c *Route53) ListHostedZonesRequest(input *ListHostedZonesInput) (req *request.Request, output *ListHostedZonesOutput) {

772

op := &request.Operation{

773

Name: opListHostedZones,

774

HTTPMethod: "GET",

775

HTTPPath: "/2013-04-01/hostedzone",

776

Paginator: &request.Paginator{

777

InputTokens: []string{"Marker"},

778

OutputTokens: []string{"NextMarker"},

779

LimitToken: "MaxItems",

780

TruncationToken: "IsTruncated",

781

782

}

783

784

if input == nil {

785

input = &ListHostedZonesInput{}

786

}

787

788

req = c.newRequest(op, input, output)

789

output = &ListHostedZonesOutput{}

790

req.Data = output

791

return

792

}

793

794

// To retrieve a list of your hosted zones, send a GET request to the 2013-04-01/hostedzone

795

// resource. The response to this request includes a HostedZones element with

796

// zero, one, or multiple HostedZone child elements. By default, the list of

797

// hosted zones is displayed on a single page. You can control the length of

798

// the page that is displayed by using the MaxItems parameter. You can use the

799

// Marker parameter to control the hosted zone that the list begins with.

800

801

// Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to

802

// a value greater than 100, Amazon Route 53 returns only the first 100.

803

func (c *Route53) ListHostedZones(input *ListHostedZonesInput) (*ListHostedZonesOutput, error) {

804

req, out := c.ListHostedZonesRequest(input)

805

err := req.Send()

806

return out, err

807

}

808

809

func (c *Route53) ListHostedZonesPages(input *ListHostedZonesInput, fn func(p *ListHostedZonesOutput, lastPage bool) (shouldContinue bool)) error {

810

page, _ := c.ListHostedZonesRequest(input)

811

return page.EachPage(func(p interface{}, lastPage bool) bool {

812

return fn(p.(*ListHostedZonesOutput), lastPage)

813

})

814

}

815

816

const opListHostedZonesByName = "ListHostedZonesByName"

817

818

// ListHostedZonesByNameRequest generates a request for the ListHostedZonesByName operation.

819

func (c *Route53) ListHostedZonesByNameRequest(input *ListHostedZonesByNameInput) (req *request.Request, output *ListHostedZonesByNameOutput) {

820

op := &request.Operation{

821

Name: opListHostedZonesByName,

822

HTTPMethod: "GET",

823

HTTPPath: "/2013-04-01/hostedzonesbyname",

824

}

825

826

if input == nil {

827

input = &ListHostedZonesByNameInput{}

828

}

829

830

req = c.newRequest(op, input, output)

831

output = &ListHostedZonesByNameOutput{}

832

req.Data = output

833

return

834

}

835

836

// To retrieve a list of your hosted zones in lexicographic order, send a GET

837

// request to the 2013-04-01/hostedzonesbyname resource. The response to this

838

// request includes a HostedZones element with zero or more HostedZone child

839

// elements lexicographically ordered by DNS name. By default, the list of hosted

840

// zones is displayed on a single page. You can control the length of the page

841

// that is displayed by using the MaxItems parameter. You can use the DNSName

842

// and HostedZoneId parameters to control the hosted zone that the list begins

843

// with.

844

845

// Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to

846

// a value greater than 100, Amazon Route 53 returns only the first 100.

847

func (c *Route53) ListHostedZonesByName(input *ListHostedZonesByNameInput) (*ListHostedZonesByNameOutput, error) {

848

req, out := c.ListHostedZonesByNameRequest(input)

849

err := req.Send()

850

return out, err

851

}

852

853

const opListResourceRecordSets = "ListResourceRecordSets"

854

855

// ListResourceRecordSetsRequest generates a request for the ListResourceRecordSets operation.

856

func (c *Route53) ListResourceRecordSetsRequest(input *ListResourceRecordSetsInput) (req *request.Request, output *ListResourceRecordSetsOutput) {

857

op := &request.Operation{

858

Name: opListResourceRecordSets,

859

HTTPMethod: "GET",

860

HTTPPath: "/2013-04-01/hostedzone/{Id}/rrset",

861

Paginator: &request.Paginator{

862

InputTokens: []string{"StartRecordName", "StartRecordType", "StartRecordIdentifier"},

863

OutputTokens: []string{"NextRecordName", "NextRecordType", "NextRecordIdentifier"},

864

LimitToken: "MaxItems",

865

TruncationToken: "IsTruncated",

866

867

}

868

869

if input == nil {

870

input = &ListResourceRecordSetsInput{}

871

}

872

873

req = c.newRequest(op, input, output)

874

output = &ListResourceRecordSetsOutput{}

875

req.Data = output

876

return

877

}

878

879

// Imagine all the resource record sets in a zone listed out in front of you.

880

// Imagine them sorted lexicographically first by DNS name (with the labels

881

// reversed, like "com.amazon.www" for example), and secondarily, lexicographically

882

// by record type. This operation retrieves at most MaxItems resource record

883

// sets from this list, in order, starting at a position specified by the Name

884

// and Type arguments:

885

886

// If both Name and Type are omitted, this means start the results at the

887

// first RRSET in the HostedZone. If Name is specified but Type is omitted,

888

// this means start the results at the first RRSET in the list whose name is

889

// greater than or equal to Name. If both Name and Type are specified, this

890

// means start the results at the first RRSET in the list whose name is greater

891

// than or equal to Name and whose type is greater than or equal to Type. It

892

// is an error to specify the Type but not the Name. Use ListResourceRecordSets

893

// to retrieve a single known record set by specifying the record set's name

894

// and type, and setting MaxItems = 1

895

896

// To retrieve all the records in a HostedZone, first pause any processes making

897

// calls to ChangeResourceRecordSets. Initially call ListResourceRecordSets

898

// without a Name and Type to get the first page of record sets. For subsequent

899

// calls, set Name and Type to the NextName and NextType values returned by

900

// the previous response.

901

902

// In the presence of concurrent ChangeResourceRecordSets calls, there is no

903

// consistency of results across calls to ListResourceRecordSets. The only way

904

// to get a consistent multi-page snapshot of all RRSETs in a zone is to stop

905

// making changes while pagination is in progress.

906

907

// However, the results from ListResourceRecordSets are consistent within a

908

// page. If MakeChange calls are taking place concurrently, the result of each

909

// one will either be completely visible in your results or not at all. You

910

// will not see partial changes, or changes that do not ultimately succeed.

911

// (This follows from the fact that MakeChange is atomic)

912

913

// The results from ListResourceRecordSets are strongly consistent with ChangeResourceRecordSets.

914

// To be precise, if a single process makes a call to ChangeResourceRecordSets

915

// and receives a successful response, the effects of that change will be visible

916

// in a subsequent call to ListResourceRecordSets by that process.

917

func (c *Route53) ListResourceRecordSets(input *ListResourceRecordSetsInput) (*ListResourceRecordSetsOutput, error) {

918

req, out := c.ListResourceRecordSetsRequest(input)

919

err := req.Send()

920

return out, err

921

}

922

923

func (c *Route53) ListResourceRecordSetsPages(input *ListResourceRecordSetsInput, fn func(p *ListResourceRecordSetsOutput, lastPage bool) (shouldContinue bool)) error {

924

page, _ := c.ListResourceRecordSetsRequest(input)

925

return page.EachPage(func(p interface{}, lastPage bool) bool {

926

return fn(p.(*ListResourceRecordSetsOutput), lastPage)

927

})

928

}

929

930

const opListReusableDelegationSets = "ListReusableDelegationSets"

931

932

// ListReusableDelegationSetsRequest generates a request for the ListReusableDelegationSets operation.

933

func (c *Route53) ListReusableDelegationSetsRequest(input *ListReusableDelegationSetsInput) (req *request.Request, output *ListReusableDelegationSetsOutput) {

934

op := &request.Operation{

935

Name: opListReusableDelegationSets,

936

HTTPMethod: "GET",

937

HTTPPath: "/2013-04-01/delegationset",

938

}

939

940

if input == nil {

941

input = &ListReusableDelegationSetsInput{}

942

}

943

944

req = c.newRequest(op, input, output)

945

output = &ListReusableDelegationSetsOutput{}

946

req.Data = output

947

return

948

}

949

950

// To retrieve a list of your reusable delegation sets, send a GET request to

951

// the 2013-04-01/delegationset resource. The response to this request includes

952

// a DelegationSets element with zero, one, or multiple DelegationSet child

953

// elements. By default, the list of delegation sets is displayed on a single

954

// page. You can control the length of the page that is displayed by using the

955

// MaxItems parameter. You can use the Marker parameter to control the delegation

956

// set that the list begins with.

957

958

// Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to

959

// a value greater than 100, Amazon Route 53 returns only the first 100.

960

func (c *Route53) ListReusableDelegationSets(input *ListReusableDelegationSetsInput) (*ListReusableDelegationSetsOutput, error) {

961

req, out := c.ListReusableDelegationSetsRequest(input)

962

err := req.Send()

963

return out, err

964

}

965

966

const opListTagsForResource = "ListTagsForResource"

967

968

// ListTagsForResourceRequest generates a request for the ListTagsForResource operation.

969

func (c *Route53) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *request.Request, output *ListTagsForResourceOutput) {

970

op := &request.Operation{

971

Name: opListTagsForResource,

972

HTTPMethod: "GET",

973

HTTPPath: "/2013-04-01/tags/{ResourceType}/{ResourceId}",

974

}

975

976

if input == nil {

977

input = &ListTagsForResourceInput{}

978

}

979

980

req = c.newRequest(op, input, output)

981

output = &ListTagsForResourceOutput{}

982

req.Data = output

983

return

984

}

985

986

func (c *Route53) ListTagsForResource(input *ListTagsForResourceInput) (*ListTagsForResourceOutput, error) {

987

req, out := c.ListTagsForResourceRequest(input)

988

err := req.Send()

989

return out, err

990

}

991

992

const opListTagsForResources = "ListTagsForResources"

993

994

// ListTagsForResourcesRequest generates a request for the ListTagsForResources operation.

995

func (c *Route53) ListTagsForResourcesRequest(input *ListTagsForResourcesInput) (req *request.Request, output *ListTagsForResourcesOutput) {

996

op := &request.Operation{

997

Name: opListTagsForResources,

998

HTTPMethod: "POST",

999

HTTPPath: "/2013-04-01/tags/{ResourceType}",

1000

}

1001

1002

if input == nil {

1003

input = &ListTagsForResourcesInput{}

1004

}

1005

1006

req = c.newRequest(op, input, output)

1007

output = &ListTagsForResourcesOutput{}

1008

req.Data = output

1009

return

1010

}

1011

1012

func (c *Route53) ListTagsForResources(input *ListTagsForResourcesInput) (*ListTagsForResourcesOutput, error) {

1013

req, out := c.ListTagsForResourcesRequest(input)

1014

err := req.Send()

1015

return out, err

1016

}

1017

1018

const opUpdateHealthCheck = "UpdateHealthCheck"

1019

1020

// UpdateHealthCheckRequest generates a request for the UpdateHealthCheck operation.

1021

func (c *Route53) UpdateHealthCheckRequest(input *UpdateHealthCheckInput) (req *request.Request, output *UpdateHealthCheckOutput) {

1022

op := &request.Operation{

1023

Name: opUpdateHealthCheck,

1024

HTTPMethod: "POST",

1025

HTTPPath: "/2013-04-01/healthcheck/{HealthCheckId}",

1026

}

1027

1028

if input == nil {

1029

input = &UpdateHealthCheckInput{}

1030

}

1031

1032

req = c.newRequest(op, input, output)

1033

output = &UpdateHealthCheckOutput{}

1034

req.Data = output

1035

return

1036

}

1037

1038

// This action updates an existing health check.

1039

1040

// To update a health check, send a POST request to the 2013-04-01/healthcheck/health

1041

// check ID resource. The request body must include an XML document with an

1042

// UpdateHealthCheckRequest element. The response returns an UpdateHealthCheckResponse

1043

// element, which contains metadata about the health check.

1044

func (c *Route53) UpdateHealthCheck(input *UpdateHealthCheckInput) (*UpdateHealthCheckOutput, error) {

1045

req, out := c.UpdateHealthCheckRequest(input)

1046

err := req.Send()

1047

return out, err

1048

}

1049

1050

const opUpdateHostedZoneComment = "UpdateHostedZoneComment"

1051

1052

// UpdateHostedZoneCommentRequest generates a request for the UpdateHostedZoneComment operation.

1053

func (c *Route53) UpdateHostedZoneCommentRequest(input *UpdateHostedZoneCommentInput) (req *request.Request, output *UpdateHostedZoneCommentOutput) {

1054

op := &request.Operation{

1055

Name: opUpdateHostedZoneComment,

1056

HTTPMethod: "POST",

1057

HTTPPath: "/2013-04-01/hostedzone/{Id}",

1058

}

1059

1060

if input == nil {

1061

input = &UpdateHostedZoneCommentInput{}

1062

}

1063

1064

req = c.newRequest(op, input, output)

1065

output = &UpdateHostedZoneCommentOutput{}

1066

req.Data = output

1067

return

1068

}

1069

1070

// To update the hosted zone comment, send a POST request to the 2013-04-01/hostedzone/hosted

1071

// zone ID resource. The request body must include an XML document with a UpdateHostedZoneCommentRequest

1072

// element. The response to this request includes the modified HostedZone element.

1073

1074

// The comment can have a maximum length of 256 characters.

1075

func (c *Route53) UpdateHostedZoneComment(input *UpdateHostedZoneCommentInput) (*UpdateHostedZoneCommentOutput, error) {

1076

req, out := c.UpdateHostedZoneCommentRequest(input)

1077

err := req.Send()

1078

return out, err

1079

}

1080

1081

// Alias resource record sets only: Information about the domain to which you

1082

// are redirecting traffic.

1083

1084

// For more information and an example, see Creating Alias Resource Record

1085

// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)

1086

// in the Amazon Route 53 Developer Guide

1087

1088

// .

1089

type AliasTarget struct {

1090

// Alias resource record sets only: The external DNS name associated with the

1091

// AWS Resource.

1092

1093

// For more information and an example, see Creating Alias Resource Record

1094

// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)

1095

// in the Amazon Route 53 Developer Guide

1096

1097

// .

1098

DNSName *string `type:"string" required:"true"`

1099

1100

// Alias resource record sets only: A boolean value that indicates whether this

1101

// Resource Record Set should respect the health status of any health checks

1102

// associated with the ALIAS target record which it is linked to.

1103

1104

// For more information and an example, see Creating Alias Resource Record

1105

// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)

1106

// in the Amazon Route 53 Developer Guide

1107

1108

// .

1109

EvaluateTargetHealth *bool `type:"boolean" required:"true"`

1110

1111

// Alias resource record sets only: The value of the hosted zone ID for the

1112

// AWS resource.

1113

1114

// For more information and an example, see Creating Alias Resource Record

1115

// Sets (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingAliasRRSets.html)

1116

// in the Amazon Route 53 Developer Guide

1117

1118

// .

1119

HostedZoneId *string `type:"string" required:"true"`

1120

1121

metadataAliasTarget `json:"-" xml:"-"`

1122

}

1123

1124

type metadataAliasTarget struct {

1125

SDKShapeTraits bool `type:"structure"`

1126

}

1127

1128

// String returns the string representation

1129

func (s AliasTarget) String() string {

1130

return awsutil.Prettify(s)

1131

}

1132

1133

// GoString returns the string representation

1134

func (s AliasTarget) GoString() string {

1135

return s.String()

1136

}

1137

1138

// A complex type that contains information about the request to associate a

1139

// VPC with an hosted zone.

1140

type AssociateVPCWithHostedZoneInput struct {

1141

// Optional: Any comments you want to include about a AssociateVPCWithHostedZoneRequest.

1142

Comment *string `type:"string"`

1143

1144

// The ID of the hosted zone you want to associate your VPC with.

1145

1146

// Note that you cannot associate a VPC with a hosted zone that doesn't have

1147

// an existing VPC association.

1148

HostedZoneId *string `location:"uri" locationName:"Id" type:"string" required:"true"`

1149

1150

// The VPC that you want your hosted zone to be associated with.

1151

VPC *VPC `type:"structure" required:"true"`

1152

1153

metadataAssociateVPCWithHostedZoneInput `json:"-" xml:"-"`

1154

}

1155

1156

type metadataAssociateVPCWithHostedZoneInput struct {

1157

SDKShapeTraits bool `locationName:"AssociateVPCWithHostedZoneRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1158

}

1159

1160

// String returns the string representation

1161

func (s AssociateVPCWithHostedZoneInput) String() string {

1162

return awsutil.Prettify(s)

1163

}

1164

1165

// GoString returns the string representation

1166

func (s AssociateVPCWithHostedZoneInput) GoString() string {

1167

return s.String()

1168

}

1169

1170

// A complex type containing the response information for the request.

1171

type AssociateVPCWithHostedZoneOutput struct {

1172

// A complex type that contains the ID, the status, and the date and time of

1173

// your AssociateVPCWithHostedZoneRequest.

1174

ChangeInfo *ChangeInfo `type:"structure" required:"true"`

1175

1176

metadataAssociateVPCWithHostedZoneOutput `json:"-" xml:"-"`

1177

}

1178

1179

type metadataAssociateVPCWithHostedZoneOutput struct {

1180

SDKShapeTraits bool `type:"structure"`

1181

}

1182

1183

// String returns the string representation

1184

func (s AssociateVPCWithHostedZoneOutput) String() string {

1185

return awsutil.Prettify(s)

1186

}

1187

1188

// GoString returns the string representation

1189

func (s AssociateVPCWithHostedZoneOutput) GoString() string {

1190

return s.String()

1191

}

1192

1193

// A complex type that contains the information for each change in a change

1194

// batch request.

1195

type Change struct {

1196

// The action to perform.

1197

1198

// Valid values: CREATE | DELETE | UPSERT

1199

Action *string `type:"string" required:"true" enum:"ChangeAction"`

1200

1201

// Information about the resource record set to create or delete.

1202

ResourceRecordSet *ResourceRecordSet `type:"structure" required:"true"`

1203

1204

metadataChange `json:"-" xml:"-"`

1205

}

1206

1207

type metadataChange struct {

1208

SDKShapeTraits bool `type:"structure"`

1209

}

1210

1211

// String returns the string representation

1212

func (s Change) String() string {

1213

return awsutil.Prettify(s)

1214

}

1215

1216

// GoString returns the string representation

1217

func (s Change) GoString() string {

1218

return s.String()

1219

}

1220

1221

// A complex type that contains an optional comment and the changes that you

1222

// want to make with a change batch request.

1223

type ChangeBatch struct {

1224

// A complex type that contains one Change element for each resource record

1225

// set that you want to create or delete.

1226

Changes []*Change `locationNameList:"Change" min:"1" type:"list" required:"true"`

1227

1228

// Optional: Any comments you want to include about a change batch request.

1229

Comment *string `type:"string"`

1230

1231

metadataChangeBatch `json:"-" xml:"-"`

1232

}

1233

1234

type metadataChangeBatch struct {

1235

SDKShapeTraits bool `type:"structure"`

1236

}

1237

1238

// String returns the string representation

1239

func (s ChangeBatch) String() string {

1240

return awsutil.Prettify(s)

1241

}

1242

1243

// GoString returns the string representation

1244

func (s ChangeBatch) GoString() string {

1245

return s.String()

1246

}

1247

1248

// A complex type that describes change information about changes made to your

1249

// hosted zone.

1250

1251

// This element contains an ID that you use when performing a GetChange action

1252

// to get detailed information about the change.

1253

type ChangeInfo struct {

1254

// A complex type that describes change information about changes made to your

1255

// hosted zone.

1256

1257

// This element contains an ID that you use when performing a GetChange action

1258

// to get detailed information about the change.

1259

Comment *string `type:"string"`

1260

1261

// The ID of the request. Use this ID to track when the change has completed

1262

// across all Amazon Route 53 DNS servers.

1263

Id *string `type:"string" required:"true"`

1264

1265

// The current state of the request. PENDING indicates that this request has

1266

// not yet been applied to all Amazon Route 53 DNS servers.

1267

1268

// Valid Values: PENDING | INSYNC

1269

Status *string `type:"string" required:"true" enum:"ChangeStatus"`

1270

1271

// The date and time the change was submitted, in the format YYYY-MM-DDThh:mm:ssZ,

1272

// as specified in the ISO 8601 standard (for example, 2009-11-19T19:37:58Z).

1273

// The Z after the time indicates that the time is listed in Coordinated Universal

1274

// Time (UTC), which is synonymous with Greenwich Mean Time in this context.

1275

SubmittedAt *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`

1276

1277

metadataChangeInfo `json:"-" xml:"-"`

1278

}

1279

1280

type metadataChangeInfo struct {

1281

SDKShapeTraits bool `type:"structure"`

1282

}

1283

1284

// String returns the string representation

1285

func (s ChangeInfo) String() string {

1286

return awsutil.Prettify(s)

1287

}

1288

1289

// GoString returns the string representation

1290

func (s ChangeInfo) GoString() string {

1291

return s.String()

1292

}

1293

1294

// A complex type that contains a change batch.

1295

type ChangeResourceRecordSetsInput struct {

1296

// A complex type that contains an optional comment and the Changes element.

1297

ChangeBatch *ChangeBatch `type:"structure" required:"true"`

1298

1299

// The ID of the hosted zone that contains the resource record sets that you

1300

// want to change.

1301

HostedZoneId *string `location:"uri" locationName:"Id" type:"string" required:"true"`

1302

1303

metadataChangeResourceRecordSetsInput `json:"-" xml:"-"`

1304

}

1305

1306

type metadataChangeResourceRecordSetsInput struct {

1307

SDKShapeTraits bool `locationName:"ChangeResourceRecordSetsRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1308

}

1309

1310

// String returns the string representation

1311

func (s ChangeResourceRecordSetsInput) String() string {

1312

return awsutil.Prettify(s)

1313

}

1314

1315

// GoString returns the string representation

1316

func (s ChangeResourceRecordSetsInput) GoString() string {

1317

return s.String()

1318

}

1319

1320

// A complex type containing the response for the request.

1321

type ChangeResourceRecordSetsOutput struct {

1322

// A complex type that contains information about changes made to your hosted

1323

// zone.

1324

1325

// This element contains an ID that you use when performing a GetChange action

1326

// to get detailed information about the change.

1327

ChangeInfo *ChangeInfo `type:"structure" required:"true"`

1328

1329

metadataChangeResourceRecordSetsOutput `json:"-" xml:"-"`

1330

}

1331

1332

type metadataChangeResourceRecordSetsOutput struct {

1333

SDKShapeTraits bool `type:"structure"`

1334

}

1335

1336

// String returns the string representation

1337

func (s ChangeResourceRecordSetsOutput) String() string {

1338

return awsutil.Prettify(s)

1339

}

1340

1341

// GoString returns the string representation

1342

func (s ChangeResourceRecordSetsOutput) GoString() string {

1343

return s.String()

1344

}

1345

1346

// A complex type containing information about a request to add, change, or

1347

// delete the tags that are associated with a resource.

1348

type ChangeTagsForResourceInput struct {

1349

// A complex type that contains a list of Tag elements. Each Tag element identifies

1350

// a tag that you want to add or update for the specified resource.

1351

AddTags []*Tag `locationNameList:"Tag" min:"1" type:"list"`

1352

1353

// A list of Tag keys that you want to remove from the specified resource.

1354

RemoveTagKeys []*string `locationNameList:"Key" min:"1" type:"list"`

1355

1356

// The ID of the resource for which you want to add, change, or delete tags.

1357

ResourceId *string `location:"uri" locationName:"ResourceId" type:"string" required:"true"`

1358

1359

// The type of the resource.

1360

1361

// - The resource type for health checks is healthcheck.

1362

1363

// - The resource type for hosted zones is hostedzone.

1364

ResourceType *string `location:"uri" locationName:"ResourceType" type:"string" required:"true" enum:"TagResourceType"`

1365

1366

metadataChangeTagsForResourceInput `json:"-" xml:"-"`

1367

}

1368

1369

type metadataChangeTagsForResourceInput struct {

1370

SDKShapeTraits bool `locationName:"ChangeTagsForResourceRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1371

}

1372

1373

// String returns the string representation

1374

func (s ChangeTagsForResourceInput) String() string {

1375

return awsutil.Prettify(s)

1376

}

1377

1378

// GoString returns the string representation

1379

func (s ChangeTagsForResourceInput) GoString() string {

1380

return s.String()

1381

}

1382

1383

// Empty response for the request.

1384

type ChangeTagsForResourceOutput struct {

1385

metadataChangeTagsForResourceOutput `json:"-" xml:"-"`

1386

}

1387

1388

type metadataChangeTagsForResourceOutput struct {

1389

SDKShapeTraits bool `type:"structure"`

1390

}

1391

1392

// String returns the string representation

1393

func (s ChangeTagsForResourceOutput) String() string {

1394

return awsutil.Prettify(s)

1395

}

1396

1397

// GoString returns the string representation

1398

func (s ChangeTagsForResourceOutput) GoString() string {

1399

return s.String()

1400

}

1401

1402

// >A complex type that contains information about the request to create a health

1403

// check.

1404

type CreateHealthCheckInput struct {

1405

// A unique string that identifies the request and that allows failed CreateHealthCheck

1406

// requests to be retried without the risk of executing the operation twice.

1407

// You must use a unique CallerReference string every time you create a health

1408

// check. CallerReference can be any unique string; you might choose to use

1409

// a string that identifies your project.

1410

1411

// Valid characters are any Unicode code points that are legal in an XML 1.0

1412

// document. The UTF-8 encoding of the value must be less than 128 bytes.

1413

CallerReference *string `min:"1" type:"string" required:"true"`

1414

1415

// A complex type that contains health check configuration.

1416

HealthCheckConfig *HealthCheckConfig `type:"structure" required:"true"`

1417

1418

metadataCreateHealthCheckInput `json:"-" xml:"-"`

1419

}

1420

1421

type metadataCreateHealthCheckInput struct {

1422

SDKShapeTraits bool `locationName:"CreateHealthCheckRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1423

}

1424

1425

// String returns the string representation

1426

func (s CreateHealthCheckInput) String() string {

1427

return awsutil.Prettify(s)

1428

}

1429

1430

// GoString returns the string representation

1431

func (s CreateHealthCheckInput) GoString() string {

1432

return s.String()

1433

}

1434

1435

// A complex type containing the response information for the new health check.

1436

type CreateHealthCheckOutput struct {

1437

// A complex type that contains identifying information about the health check.

1438

HealthCheck *HealthCheck `type:"structure" required:"true"`

1439

1440

// The unique URL representing the new health check.

1441

Location *string `location:"header" locationName:"Location" type:"string" required:"true"`

1442

1443

metadataCreateHealthCheckOutput `json:"-" xml:"-"`

1444

}

1445

1446

type metadataCreateHealthCheckOutput struct {

1447

SDKShapeTraits bool `type:"structure"`

1448

}

1449

1450

// String returns the string representation

1451

func (s CreateHealthCheckOutput) String() string {

1452

return awsutil.Prettify(s)

1453

}

1454

1455

// GoString returns the string representation

1456

func (s CreateHealthCheckOutput) GoString() string {

1457

return s.String()

1458

}

1459

1460

// A complex type that contains information about the request to create a hosted

1461

// zone.

1462

type CreateHostedZoneInput struct {

1463

// A unique string that identifies the request and that allows failed CreateHostedZone

1464

// requests to be retried without the risk of executing the operation twice.

1465

// You must use a unique CallerReference string every time you create a hosted

1466

// zone. CallerReference can be any unique string; you might choose to use a

1467

// string that identifies your project, such as DNSMigration_01.

1468

1469

// Valid characters are any Unicode code points that are legal in an XML 1.0

1470

// document. The UTF-8 encoding of the value must be less than 128 bytes.

1471

CallerReference *string `min:"1" type:"string" required:"true"`

1472

1473

// The delegation set id of the reusable delgation set whose NS records you

1474

// want to assign to the new hosted zone.

1475

DelegationSetId *string `type:"string"`

1476

1477

// A complex type that contains an optional comment about your hosted zone.

1478

HostedZoneConfig *HostedZoneConfig `type:"structure"`

1479

1480

// The name of the domain. This must be a fully-specified domain, for example,

1481

// www.example.com. The trailing dot is optional; Route 53 assumes that the

1482

// domain name is fully qualified. This means that Route 53 treats www.example.com

1483

// (without a trailing dot) and www.example.com. (with a trailing dot) as identical.

1484

1485

// This is the name you have registered with your DNS registrar. You should

1486

// ask your registrar to change the authoritative name servers for your domain

1487

// to the set of NameServers elements returned in DelegationSet.

1488

Name *string `type:"string" required:"true"`

1489

1490

// The VPC that you want your hosted zone to be associated with. By providing

1491

// this parameter, your newly created hosted cannot be resolved anywhere other

1492

// than the given VPC.

1493

VPC *VPC `type:"structure"`

1494

1495

metadataCreateHostedZoneInput `json:"-" xml:"-"`

1496

}

1497

1498

type metadataCreateHostedZoneInput struct {

1499

SDKShapeTraits bool `locationName:"CreateHostedZoneRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1500

}

1501

1502

// String returns the string representation

1503

func (s CreateHostedZoneInput) String() string {

1504

return awsutil.Prettify(s)

1505

}

1506

1507

// GoString returns the string representation

1508

func (s CreateHostedZoneInput) GoString() string {

1509

return s.String()

1510

}

1511

1512

// A complex type containing the response information for the new hosted zone.

1513

type CreateHostedZoneOutput struct {

1514

// A complex type that contains information about the request to create a hosted

1515

// zone. This includes an ID that you use when you call the GetChange action

1516

// to get the current status of the change request.

1517

ChangeInfo *ChangeInfo `type:"structure" required:"true"`

1518

1519

// A complex type that contains name server information.

1520

DelegationSet *DelegationSet `type:"structure" required:"true"`

1521

1522

// A complex type that contains identifying information about the hosted zone.

1523

HostedZone *HostedZone `type:"structure" required:"true"`

1524

1525

// The unique URL representing the new hosted zone.

1526

Location *string `location:"header" locationName:"Location" type:"string" required:"true"`

1527

1528

VPC *VPC `type:"structure"`

1529

1530

metadataCreateHostedZoneOutput `json:"-" xml:"-"`

1531

}

1532

1533

type metadataCreateHostedZoneOutput struct {

1534

SDKShapeTraits bool `type:"structure"`

1535

}

1536

1537

// String returns the string representation

1538

func (s CreateHostedZoneOutput) String() string {

1539

return awsutil.Prettify(s)

1540

}

1541

1542

// GoString returns the string representation

1543

func (s CreateHostedZoneOutput) GoString() string {

1544

return s.String()

1545

}

1546

1547

type CreateReusableDelegationSetInput struct {

1548

// A unique string that identifies the request and that allows failed CreateReusableDelegationSet

1549

// requests to be retried without the risk of executing the operation twice.

1550

// You must use a unique CallerReference string every time you create a reusable

1551

// delegation set. CallerReference can be any unique string; you might choose

1552

// to use a string that identifies your project, such as DNSMigration_01.

1553

1554

// Valid characters are any Unicode code points that are legal in an XML 1.0

1555

// document. The UTF-8 encoding of the value must be less than 128 bytes.

1556

CallerReference *string `min:"1" type:"string" required:"true"`

1557

1558

// The ID of the hosted zone whose delegation set you want to mark as reusable.

1559

// It is an optional parameter.

1560

HostedZoneId *string `type:"string"`

1561

1562

metadataCreateReusableDelegationSetInput `json:"-" xml:"-"`

1563

}

1564

1565

type metadataCreateReusableDelegationSetInput struct {

1566

SDKShapeTraits bool `locationName:"CreateReusableDelegationSetRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1567

}

1568

1569

// String returns the string representation

1570

func (s CreateReusableDelegationSetInput) String() string {

1571

return awsutil.Prettify(s)

1572

}

1573

1574

// GoString returns the string representation

1575

func (s CreateReusableDelegationSetInput) GoString() string {

1576

return s.String()

1577

}

1578

1579

type CreateReusableDelegationSetOutput struct {

1580

// A complex type that contains name server information.

1581

DelegationSet *DelegationSet `type:"structure" required:"true"`

1582

1583

// The unique URL representing the new reusbale delegation set.

1584

Location *string `location:"header" locationName:"Location" type:"string" required:"true"`

1585

1586

metadataCreateReusableDelegationSetOutput `json:"-" xml:"-"`

1587

}

1588

1589

type metadataCreateReusableDelegationSetOutput struct {

1590

SDKShapeTraits bool `type:"structure"`

1591

}

1592

1593

// String returns the string representation

1594

func (s CreateReusableDelegationSetOutput) String() string {

1595

return awsutil.Prettify(s)

1596

}

1597

1598

// GoString returns the string representation

1599

func (s CreateReusableDelegationSetOutput) GoString() string {

1600

return s.String()

1601

}

1602

1603

// A complex type that contains name server information.

1604

type DelegationSet struct {

1605

CallerReference *string `min:"1" type:"string"`

1606

1607

Id *string `type:"string"`

1608

1609

// A complex type that contains the authoritative name servers for the hosted

1610

// zone. Use the method provided by your domain registrar to add an NS record

1611

// to your domain for each NameServer that is assigned to your hosted zone.

1612

NameServers []*string `locationNameList:"NameServer" min:"1" type:"list" required:"true"`

1613

1614

metadataDelegationSet `json:"-" xml:"-"`

1615

}

1616

1617

type metadataDelegationSet struct {

1618

SDKShapeTraits bool `type:"structure"`

1619

}

1620

1621

// String returns the string representation

1622

func (s DelegationSet) String() string {

1623

return awsutil.Prettify(s)

1624

}

1625

1626

// GoString returns the string representation

1627

func (s DelegationSet) GoString() string {

1628

return s.String()

1629

}

1630

1631

// A complex type containing the request information for delete health check.

1632

type DeleteHealthCheckInput struct {

1633

// The ID of the health check to delete.

1634

HealthCheckId *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`

1635

1636

metadataDeleteHealthCheckInput `json:"-" xml:"-"`

1637

}

1638

1639

type metadataDeleteHealthCheckInput struct {

1640

SDKShapeTraits bool `type:"structure"`

1641

}

1642

1643

// String returns the string representation

1644

func (s DeleteHealthCheckInput) String() string {

1645

return awsutil.Prettify(s)

1646

}

1647

1648

// GoString returns the string representation

1649

func (s DeleteHealthCheckInput) GoString() string {

1650

return s.String()

1651

}

1652

1653

// Empty response for the request.

1654

type DeleteHealthCheckOutput struct {

1655

metadataDeleteHealthCheckOutput `json:"-" xml:"-"`

1656

}

1657

1658

type metadataDeleteHealthCheckOutput struct {

1659

SDKShapeTraits bool `type:"structure"`

1660

}

1661

1662

// String returns the string representation

1663

func (s DeleteHealthCheckOutput) String() string {

1664

return awsutil.Prettify(s)

1665

}

1666

1667

// GoString returns the string representation

1668

func (s DeleteHealthCheckOutput) GoString() string {

1669

return s.String()

1670

}

1671

1672

// A complex type that contains information about the hosted zone that you want

1673

// to delete.

1674

type DeleteHostedZoneInput struct {

1675

// The ID of the hosted zone you want to delete.

1676

Id *string `location:"uri" locationName:"Id" type:"string" required:"true"`

1677

1678

metadataDeleteHostedZoneInput `json:"-" xml:"-"`

1679

}

1680

1681

type metadataDeleteHostedZoneInput struct {

1682

SDKShapeTraits bool `type:"structure"`

1683

}

1684

1685

// String returns the string representation

1686

func (s DeleteHostedZoneInput) String() string {

1687

return awsutil.Prettify(s)

1688

}

1689

1690

// GoString returns the string representation

1691

func (s DeleteHostedZoneInput) GoString() string {

1692

return s.String()

1693

}

1694

1695

// A complex type containing the response information for the request.

1696

type DeleteHostedZoneOutput struct {

1697

// A complex type that contains the ID, the status, and the date and time of

1698

// your delete request.

1699

ChangeInfo *ChangeInfo `type:"structure" required:"true"`

1700

1701

metadataDeleteHostedZoneOutput `json:"-" xml:"-"`

1702

}

1703

1704

type metadataDeleteHostedZoneOutput struct {

1705

SDKShapeTraits bool `type:"structure"`

1706

}

1707

1708

// String returns the string representation

1709

func (s DeleteHostedZoneOutput) String() string {

1710

return awsutil.Prettify(s)

1711

}

1712

1713

// GoString returns the string representation

1714

func (s DeleteHostedZoneOutput) GoString() string {

1715

return s.String()

1716

}

1717

1718

// A complex type containing the information for the delete request.

1719

type DeleteReusableDelegationSetInput struct {

1720

// The ID of the reusable delegation set you want to delete.

1721

Id *string `location:"uri" locationName:"Id" type:"string" required:"true"`

1722

1723

metadataDeleteReusableDelegationSetInput `json:"-" xml:"-"`

1724

}

1725

1726

type metadataDeleteReusableDelegationSetInput struct {

1727

SDKShapeTraits bool `type:"structure"`

1728

}

1729

1730

// String returns the string representation

1731

func (s DeleteReusableDelegationSetInput) String() string {

1732

return awsutil.Prettify(s)

1733

}

1734

1735

// GoString returns the string representation

1736

func (s DeleteReusableDelegationSetInput) GoString() string {

1737

return s.String()

1738

}

1739

1740

// Empty response for the request.

1741

type DeleteReusableDelegationSetOutput struct {

1742

metadataDeleteReusableDelegationSetOutput `json:"-" xml:"-"`

1743

}

1744

1745

type metadataDeleteReusableDelegationSetOutput struct {

1746

SDKShapeTraits bool `type:"structure"`

1747

}

1748

1749

// String returns the string representation

1750

func (s DeleteReusableDelegationSetOutput) String() string {

1751

return awsutil.Prettify(s)

1752

}

1753

1754

// GoString returns the string representation

1755

func (s DeleteReusableDelegationSetOutput) GoString() string {

1756

return s.String()

1757

}

1758

1759

// A complex type that contains information about the request to disassociate

1760

// a VPC from an hosted zone.

1761

type DisassociateVPCFromHostedZoneInput struct {

1762

// Optional: Any comments you want to include about a DisassociateVPCFromHostedZoneRequest.

1763

Comment *string `type:"string"`

1764

1765

// The ID of the hosted zone you want to disassociate your VPC from.

1766

1767

// Note that you cannot disassociate the last VPC from a hosted zone.

1768

HostedZoneId *string `location:"uri" locationName:"Id" type:"string" required:"true"`

1769

1770

// The VPC that you want your hosted zone to be disassociated from.

1771

VPC *VPC `type:"structure" required:"true"`

1772

1773

metadataDisassociateVPCFromHostedZoneInput `json:"-" xml:"-"`

1774

}

1775

1776

type metadataDisassociateVPCFromHostedZoneInput struct {

1777

SDKShapeTraits bool `locationName:"DisassociateVPCFromHostedZoneRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

1778

}

1779

1780

// String returns the string representation

1781

func (s DisassociateVPCFromHostedZoneInput) String() string {

1782

return awsutil.Prettify(s)

1783

}

1784

1785

// GoString returns the string representation

1786

func (s DisassociateVPCFromHostedZoneInput) GoString() string {

1787

return s.String()

1788

}

1789

1790

// A complex type containing the response information for the request.

1791

type DisassociateVPCFromHostedZoneOutput struct {

1792

// A complex type that contains the ID, the status, and the date and time of

1793

// your DisassociateVPCFromHostedZoneRequest.

1794

ChangeInfo *ChangeInfo `type:"structure" required:"true"`

1795

1796

metadataDisassociateVPCFromHostedZoneOutput `json:"-" xml:"-"`

1797

}

1798

1799

type metadataDisassociateVPCFromHostedZoneOutput struct {

1800

SDKShapeTraits bool `type:"structure"`

1801

}

1802

1803

// String returns the string representation

1804

func (s DisassociateVPCFromHostedZoneOutput) String() string {

1805

return awsutil.Prettify(s)

1806

}

1807

1808

// GoString returns the string representation

1809

func (s DisassociateVPCFromHostedZoneOutput) GoString() string {

1810

return s.String()

1811

}

1812

1813

// A complex type that contains information about a geo location.

1814

type GeoLocation struct {

1815

// The code for a continent geo location. Note: only continent locations have

1816

// a continent code.

1817

1818

// Valid values: AF | AN | AS | EU | OC | NA | SA

1819

1820

// Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode

1821

// returns an InvalidInput error.

1822

ContinentCode *string `min:"2" type:"string"`

1823

1824

// The code for a country geo location. The default location uses '*' for the

1825

// country code and will match all locations that are not matched by a geo location.

1826

1827

// The default geo location uses a * for the country code. All other country

1828

// codes follow the ISO 3166 two-character code.

1829

CountryCode *string `min:"1" type:"string"`

1830

1831

// The code for a country's subdivision (e.g., a province of Canada). A subdivision

1832

// code is only valid with the appropriate country code.

1833

1834

// Constraint: Specifying SubdivisionCode without CountryCode returns an InvalidInput

1835

// error.

1836

SubdivisionCode *string `min:"1" type:"string"`

1837

1838

metadataGeoLocation `json:"-" xml:"-"`

1839

}

1840

1841

type metadataGeoLocation struct {

1842

SDKShapeTraits bool `type:"structure"`

1843

}

1844

1845

// String returns the string representation

1846

func (s GeoLocation) String() string {

1847

return awsutil.Prettify(s)

1848

}

1849

1850

// GoString returns the string representation

1851

func (s GeoLocation) GoString() string {

1852

return s.String()

1853

}

1854

1855

// A complex type that contains information about a GeoLocation.

1856

type GeoLocationDetails struct {

1857

// The code for a continent geo location. Note: only continent locations have

1858

// a continent code.

1859

ContinentCode *string `min:"2" type:"string"`

1860

1861

// The name of the continent. This element is only present if ContinentCode

1862

// is also present.

1863

ContinentName *string `min:"1" type:"string"`

1864

1865

// The code for a country geo location. The default location uses '*' for the

1866

// country code and will match all locations that are not matched by a geo location.

1867

1868

// The default geo location uses a * for the country code. All other country

1869

// codes follow the ISO 3166 two-character code.

1870

CountryCode *string `min:"1" type:"string"`

1871

1872

// The name of the country. This element is only present if CountryCode is also

1873

// present.

1874

CountryName *string `min:"1" type:"string"`

1875

1876

// The code for a country's subdivision (e.g., a province of Canada). A subdivision

1877

// code is only valid with the appropriate country code.

1878

SubdivisionCode *string `min:"1" type:"string"`

1879

1880

// The name of the subdivision. This element is only present if SubdivisionCode

1881

// is also present.

1882

SubdivisionName *string `min:"1" type:"string"`

1883

1884

metadataGeoLocationDetails `json:"-" xml:"-"`

1885

}

1886

1887

type metadataGeoLocationDetails struct {

1888

SDKShapeTraits bool `type:"structure"`

1889

}

1890

1891

// String returns the string representation

1892

func (s GeoLocationDetails) String() string {

1893

return awsutil.Prettify(s)

1894

}

1895

1896

// GoString returns the string representation

1897

func (s GeoLocationDetails) GoString() string {

1898

return s.String()

1899

}

1900

1901

// The input for a GetChange request.

1902

type GetChangeInput struct {

1903

// The ID of the change batch request. The value that you specify here is the

1904

// value that ChangeResourceRecordSets returned in the Id element when you submitted

1905

// the request.

1906

Id *string `location:"uri" locationName:"Id" type:"string" required:"true"`

1907

1908

metadataGetChangeInput `json:"-" xml:"-"`

1909

}

1910

1911

type metadataGetChangeInput struct {

1912

SDKShapeTraits bool `type:"structure"`

1913

}

1914

1915

// String returns the string representation

1916

func (s GetChangeInput) String() string {

1917

return awsutil.Prettify(s)

1918

}

1919

1920

// GoString returns the string representation

1921

func (s GetChangeInput) GoString() string {

1922

return s.String()

1923

}

1924

1925

// A complex type that contains the ChangeInfo element.

1926

type GetChangeOutput struct {

1927

// A complex type that contains information about the specified change batch,

1928

// including the change batch ID, the status of the change, and the date and

1929

// time of the request.

1930

ChangeInfo *ChangeInfo `type:"structure" required:"true"`

1931

1932

metadataGetChangeOutput `json:"-" xml:"-"`

1933

}

1934

1935

type metadataGetChangeOutput struct {

1936

SDKShapeTraits bool `type:"structure"`

1937

}

1938

1939

// String returns the string representation

1940

func (s GetChangeOutput) String() string {

1941

return awsutil.Prettify(s)

1942

}

1943

1944

// GoString returns the string representation

1945

func (s GetChangeOutput) GoString() string {

1946

return s.String()

1947

}

1948

1949

// Empty request.

1950

type GetCheckerIpRangesInput struct {

1951

metadataGetCheckerIpRangesInput `json:"-" xml:"-"`

1952

}

1953

1954

type metadataGetCheckerIpRangesInput struct {

1955

SDKShapeTraits bool `type:"structure"`

1956

}

1957

1958

// String returns the string representation

1959

func (s GetCheckerIpRangesInput) String() string {

1960

return awsutil.Prettify(s)

1961

}

1962

1963

// GoString returns the string representation

1964

func (s GetCheckerIpRangesInput) GoString() string {

1965

return s.String()

1966

}

1967

1968

// A complex type that contains the CheckerIpRanges element.

1969

type GetCheckerIpRangesOutput struct {

1970

// A complex type that contains sorted list of IP ranges in CIDR format for

1971

// Amazon Route 53 health checkers.

1972

CheckerIpRanges []*string `type:"list" required:"true"`

1973

1974

metadataGetCheckerIpRangesOutput `json:"-" xml:"-"`

1975

}

1976

1977

type metadataGetCheckerIpRangesOutput struct {

1978

SDKShapeTraits bool `type:"structure"`

1979

}

1980

1981

// String returns the string representation

1982

func (s GetCheckerIpRangesOutput) String() string {

1983

return awsutil.Prettify(s)

1984

}

1985

1986

// GoString returns the string representation

1987

func (s GetCheckerIpRangesOutput) GoString() string {

1988

return s.String()

1989

}

1990

1991

// A complex type that contains information about the request to get a geo location.

1992

type GetGeoLocationInput struct {

1993

// The code for a continent geo location. Note: only continent locations have

1994

// a continent code.

1995

1996

// Valid values: AF | AN | AS | EU | OC | NA | SA

1997

1998

// Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode

1999

// returns an InvalidInput error.

2000

ContinentCode *string `location:"querystring" locationName:"continentcode" min:"2" type:"string"`

2001

2002

// The code for a country geo location. The default location uses '*' for the

2003

// country code and will match all locations that are not matched by a geo location.

2004

2005

// The default geo location uses a * for the country code. All other country

2006

// codes follow the ISO 3166 two-character code.

2007

CountryCode *string `location:"querystring" locationName:"countrycode" min:"1" type:"string"`

2008

2009

// The code for a country's subdivision (e.g., a province of Canada). A subdivision

2010

// code is only valid with the appropriate country code.

2011

2012

// Constraint: Specifying SubdivisionCode without CountryCode returns an InvalidInput

2013

// error.

2014

SubdivisionCode *string `location:"querystring" locationName:"subdivisioncode" min:"1" type:"string"`

2015

2016

metadataGetGeoLocationInput `json:"-" xml:"-"`

2017

}

2018

2019

type metadataGetGeoLocationInput struct {

2020

SDKShapeTraits bool `type:"structure"`

2021

}

2022

2023

// String returns the string representation

2024

func (s GetGeoLocationInput) String() string {

2025

return awsutil.Prettify(s)

2026

}

2027

2028

// GoString returns the string representation

2029

func (s GetGeoLocationInput) GoString() string {

2030

return s.String()

2031

}

2032

2033

// A complex type containing information about the specified geo location.

2034

type GetGeoLocationOutput struct {

2035

// A complex type that contains the information about the specified geo location.

2036

GeoLocationDetails *GeoLocationDetails `type:"structure" required:"true"`

2037

2038

metadataGetGeoLocationOutput `json:"-" xml:"-"`

2039

}

2040

2041

type metadataGetGeoLocationOutput struct {

2042

SDKShapeTraits bool `type:"structure"`

2043

}

2044

2045

// String returns the string representation

2046

func (s GetGeoLocationOutput) String() string {

2047

return awsutil.Prettify(s)

2048

}

2049

2050

// GoString returns the string representation

2051

func (s GetGeoLocationOutput) GoString() string {

2052

return s.String()

2053

}

2054

2055

// To retrieve a count of all your health checks, send a GET request to the

2056

// 2013-04-01/healthcheckcount resource.

2057

type GetHealthCheckCountInput struct {

2058

metadataGetHealthCheckCountInput `json:"-" xml:"-"`

2059

}

2060

2061

type metadataGetHealthCheckCountInput struct {

2062

SDKShapeTraits bool `type:"structure"`

2063

}

2064

2065

// String returns the string representation

2066

func (s GetHealthCheckCountInput) String() string {

2067

return awsutil.Prettify(s)

2068

}

2069

2070

// GoString returns the string representation

2071

func (s GetHealthCheckCountInput) GoString() string {

2072

return s.String()

2073

}

2074

2075

// A complex type that contains the count of health checks associated with the

2076

// current AWS account.

2077

type GetHealthCheckCountOutput struct {

2078

// The number of health checks associated with the current AWS account.

2079

HealthCheckCount *int64 `type:"long" required:"true"`

2080

2081

metadataGetHealthCheckCountOutput `json:"-" xml:"-"`

2082

}

2083

2084

type metadataGetHealthCheckCountOutput struct {

2085

SDKShapeTraits bool `type:"structure"`

2086

}

2087

2088

// String returns the string representation

2089

func (s GetHealthCheckCountOutput) String() string {

2090

return awsutil.Prettify(s)

2091

}

2092

2093

// GoString returns the string representation

2094

func (s GetHealthCheckCountOutput) GoString() string {

2095

return s.String()

2096

}

2097

2098

// A complex type that contains information about the request to get a health

2099

// check.

2100

type GetHealthCheckInput struct {

2101

// The ID of the health check to retrieve.

2102

HealthCheckId *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`

2103

2104

metadataGetHealthCheckInput `json:"-" xml:"-"`

2105

}

2106

2107

type metadataGetHealthCheckInput struct {

2108

SDKShapeTraits bool `type:"structure"`

2109

}

2110

2111

// String returns the string representation

2112

func (s GetHealthCheckInput) String() string {

2113

return awsutil.Prettify(s)

2114

}

2115

2116

// GoString returns the string representation

2117

func (s GetHealthCheckInput) GoString() string {

2118

return s.String()

2119

}

2120

2121

// A complex type that contains information about the request to get the most

2122

// recent failure reason for a health check.

2123

type GetHealthCheckLastFailureReasonInput struct {

2124

// The ID of the health check for which you want to retrieve the reason for

2125

// the most recent failure.

2126

HealthCheckId *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`

2127

2128

metadataGetHealthCheckLastFailureReasonInput `json:"-" xml:"-"`

2129

}

2130

2131

type metadataGetHealthCheckLastFailureReasonInput struct {

2132

SDKShapeTraits bool `type:"structure"`

2133

}

2134

2135

// String returns the string representation

2136

func (s GetHealthCheckLastFailureReasonInput) String() string {

2137

return awsutil.Prettify(s)

2138

}

2139

2140

// GoString returns the string representation

2141

func (s GetHealthCheckLastFailureReasonInput) GoString() string {

2142

return s.String()

2143

}

2144

2145

// A complex type that contains information about the most recent failure for

2146

// the specified health check.

2147

type GetHealthCheckLastFailureReasonOutput struct {

2148

// A list that contains one HealthCheckObservation element for each Route 53

2149

// health checker.

2150

HealthCheckObservations []*HealthCheckObservation `locationNameList:"HealthCheckObservation" type:"list" required:"true"`

2151

2152

metadataGetHealthCheckLastFailureReasonOutput `json:"-" xml:"-"`

2153

}

2154

2155

type metadataGetHealthCheckLastFailureReasonOutput struct {

2156

SDKShapeTraits bool `type:"structure"`

2157

}

2158

2159

// String returns the string representation

2160

func (s GetHealthCheckLastFailureReasonOutput) String() string {

2161

return awsutil.Prettify(s)

2162

}

2163

2164

// GoString returns the string representation

2165

func (s GetHealthCheckLastFailureReasonOutput) GoString() string {

2166

return s.String()

2167

}

2168

2169

// A complex type containing information about the specified health check.

2170

type GetHealthCheckOutput struct {

2171

// A complex type that contains the information about the specified health check.

2172

HealthCheck *HealthCheck `type:"structure" required:"true"`

2173

2174

metadataGetHealthCheckOutput `json:"-" xml:"-"`

2175

}

2176

2177

type metadataGetHealthCheckOutput struct {

2178

SDKShapeTraits bool `type:"structure"`

2179

}

2180

2181

// String returns the string representation

2182

func (s GetHealthCheckOutput) String() string {

2183

return awsutil.Prettify(s)

2184

}

2185

2186

// GoString returns the string representation

2187

func (s GetHealthCheckOutput) GoString() string {

2188

return s.String()

2189

}

2190

2191

// A complex type that contains information about the request to get health

2192

// check status for a health check.

2193

type GetHealthCheckStatusInput struct {

2194

// The ID of the health check for which you want to retrieve the most recent

2195

// status.

2196

HealthCheckId *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`

2197

2198

metadataGetHealthCheckStatusInput `json:"-" xml:"-"`

2199

}

2200

2201

type metadataGetHealthCheckStatusInput struct {

2202

SDKShapeTraits bool `type:"structure"`

2203

}

2204

2205

// String returns the string representation

2206

func (s GetHealthCheckStatusInput) String() string {

2207

return awsutil.Prettify(s)

2208

}

2209

2210

// GoString returns the string representation

2211

func (s GetHealthCheckStatusInput) GoString() string {

2212

return s.String()

2213

}

2214

2215

// A complex type that contains information about the status of the specified

2216

// health check.

2217

type GetHealthCheckStatusOutput struct {

2218

// A list that contains one HealthCheckObservation element for each Route 53

2219

// health checker.

2220

HealthCheckObservations []*HealthCheckObservation `locationNameList:"HealthCheckObservation" type:"list" required:"true"`

2221

2222

metadataGetHealthCheckStatusOutput `json:"-" xml:"-"`

2223

}

2224

2225

type metadataGetHealthCheckStatusOutput struct {

2226

SDKShapeTraits bool `type:"structure"`

2227

}

2228

2229

// String returns the string representation

2230

func (s GetHealthCheckStatusOutput) String() string {

2231

return awsutil.Prettify(s)

2232

}

2233

2234

// GoString returns the string representation

2235

func (s GetHealthCheckStatusOutput) GoString() string {

2236

return s.String()

2237

}

2238

2239

// To retrieve a count of all your hosted zones, send a GET request to the 2013-04-01/hostedzonecount

2240

// resource.

2241

type GetHostedZoneCountInput struct {

2242

metadataGetHostedZoneCountInput `json:"-" xml:"-"`

2243

}

2244

2245

type metadataGetHostedZoneCountInput struct {

2246

SDKShapeTraits bool `type:"structure"`

2247

}

2248

2249

// String returns the string representation

2250

func (s GetHostedZoneCountInput) String() string {

2251

return awsutil.Prettify(s)

2252

}

2253

2254

// GoString returns the string representation

2255

func (s GetHostedZoneCountInput) GoString() string {

2256

return s.String()

2257

}

2258

2259

// A complex type that contains the count of hosted zones associated with the

2260

// current AWS account.

2261

type GetHostedZoneCountOutput struct {

2262

// The number of hosted zones associated with the current AWS account.

2263

HostedZoneCount *int64 `type:"long" required:"true"`

2264

2265

metadataGetHostedZoneCountOutput `json:"-" xml:"-"`

2266

}

2267

2268

type metadataGetHostedZoneCountOutput struct {

2269

SDKShapeTraits bool `type:"structure"`

2270

}

2271

2272

// String returns the string representation

2273

func (s GetHostedZoneCountOutput) String() string {

2274

return awsutil.Prettify(s)

2275

}

2276

2277

// GoString returns the string representation

2278

func (s GetHostedZoneCountOutput) GoString() string {

2279

return s.String()

2280

}

2281

2282

// The input for a GetHostedZone request.

2283

type GetHostedZoneInput struct {

2284

// The ID of the hosted zone for which you want to get a list of the name servers

2285

// in the delegation set.

2286

Id *string `location:"uri" locationName:"Id" type:"string" required:"true"`

2287

2288

metadataGetHostedZoneInput `json:"-" xml:"-"`

2289

}

2290

2291

type metadataGetHostedZoneInput struct {

2292

SDKShapeTraits bool `type:"structure"`

2293

}

2294

2295

// String returns the string representation

2296

func (s GetHostedZoneInput) String() string {

2297

return awsutil.Prettify(s)

2298

}

2299

2300

// GoString returns the string representation

2301

func (s GetHostedZoneInput) GoString() string {

2302

return s.String()

2303

}

2304

2305

// A complex type containing information about the specified hosted zone.

2306

type GetHostedZoneOutput struct {

2307

// A complex type that contains information about the name servers for the specified

2308

// hosted zone.

2309

DelegationSet *DelegationSet `type:"structure"`

2310

2311

// A complex type that contains the information about the specified hosted zone.

2312

HostedZone *HostedZone `type:"structure" required:"true"`

2313

2314

// A complex type that contains information about VPCs associated with the specified

2315

// hosted zone.

2316

VPCs []*VPC `locationNameList:"VPC" min:"1" type:"list"`

2317

2318

metadataGetHostedZoneOutput `json:"-" xml:"-"`

2319

}

2320

2321

type metadataGetHostedZoneOutput struct {

2322

SDKShapeTraits bool `type:"structure"`

2323

}

2324

2325

// String returns the string representation

2326

func (s GetHostedZoneOutput) String() string {

2327

return awsutil.Prettify(s)

2328

}

2329

2330

// GoString returns the string representation

2331

func (s GetHostedZoneOutput) GoString() string {

2332

return s.String()

2333

}

2334

2335

// The input for a GetReusableDelegationSet request.

2336

type GetReusableDelegationSetInput struct {

2337

// The ID of the reusable delegation set for which you want to get a list of

2338

// the name server.

2339

Id *string `location:"uri" locationName:"Id" type:"string" required:"true"`

2340

2341

metadataGetReusableDelegationSetInput `json:"-" xml:"-"`

2342

}

2343

2344

type metadataGetReusableDelegationSetInput struct {

2345

SDKShapeTraits bool `type:"structure"`

2346

}

2347

2348

// String returns the string representation

2349

func (s GetReusableDelegationSetInput) String() string {

2350

return awsutil.Prettify(s)

2351

}

2352

2353

// GoString returns the string representation

2354

func (s GetReusableDelegationSetInput) GoString() string {

2355

return s.String()

2356

}

2357

2358

// A complex type containing information about the specified reusable delegation

2359

// set.

2360

type GetReusableDelegationSetOutput struct {

2361

// A complex type that contains the information about the nameservers for the

2362

// specified delegation set ID.

2363

DelegationSet *DelegationSet `type:"structure" required:"true"`

2364

2365

metadataGetReusableDelegationSetOutput `json:"-" xml:"-"`

2366

}

2367

2368

type metadataGetReusableDelegationSetOutput struct {

2369

SDKShapeTraits bool `type:"structure"`

2370

}

2371

2372

// String returns the string representation

2373

func (s GetReusableDelegationSetOutput) String() string {

2374

return awsutil.Prettify(s)

2375

}

2376

2377

// GoString returns the string representation

2378

func (s GetReusableDelegationSetOutput) GoString() string {

2379

return s.String()

2380

}

2381

2382

// A complex type that contains identifying information about the health check.

2383

type HealthCheck struct {

2384

// A unique string that identifies the request to create the health check.

2385

CallerReference *string `min:"1" type:"string" required:"true"`

2386

2387

// A complex type that contains the health check configuration.

2388

HealthCheckConfig *HealthCheckConfig `type:"structure" required:"true"`

2389

2390

// The version of the health check. You can optionally pass this value in a

2391

// call to UpdateHealthCheck to prevent overwriting another change to the health

2392

// check.

2393

HealthCheckVersion *int64 `min:"1" type:"long" required:"true"`

2394

2395

// The ID of the specified health check.

2396

Id *string `type:"string" required:"true"`

2397

2398

metadataHealthCheck `json:"-" xml:"-"`

2399

}

2400

2401

type metadataHealthCheck struct {

2402

SDKShapeTraits bool `type:"structure"`

2403

}

2404

2405

// String returns the string representation

2406

func (s HealthCheck) String() string {

2407

return awsutil.Prettify(s)

2408

}

2409

2410

// GoString returns the string representation

2411

func (s HealthCheck) GoString() string {

2412

return s.String()

2413

}

2414

2415

// A complex type that contains the health check configuration.

2416

type HealthCheckConfig struct {

2417

// For a specified parent health check, a list of HealthCheckId values for the

2418

// associated child health checks.

2419

ChildHealthChecks []*string `locationNameList:"ChildHealthCheck" type:"list"`

2420

2421

// The number of consecutive health checks that an endpoint must pass or fail

2422

// for Route 53 to change the current status of the endpoint from unhealthy

2423

// to healthy or vice versa.

2424

2425

// Valid values are integers between 1 and 10. For more information, see "How

2426

// Amazon Route 53 Determines Whether an Endpoint Is Healthy" in the Amazon

2427

// Route 53 Developer Guide.

2428

FailureThreshold *int64 `min:"1" type:"integer"`

2429

2430

// Fully qualified domain name of the instance to be health checked.

2431

FullyQualifiedDomainName *string `type:"string"`

2432

2433

// The minimum number of child health checks that must be healthy for Route

2434

// 53 to consider the parent health check to be healthy. Valid values are integers

2435

// between 0 and 256, inclusive.

2436

HealthThreshold *int64 `type:"integer"`

2437

2438

// IP Address of the instance being checked.

2439

IPAddress *string `type:"string"`

2440

2441

// A boolean value that indicates whether the status of health check should

2442

// be inverted. For example, if a health check is healthy but Inverted is True,

2443

// then Route 53 considers the health check to be unhealthy.

2444

Inverted *bool `type:"boolean"`

2445

2446

// A Boolean value that indicates whether you want Route 53 to measure the latency

2447

// between health checkers in multiple AWS regions and your endpoint and to

2448

// display CloudWatch latency graphs in the Route 53 console.

2449

MeasureLatency *bool `type:"boolean"`

2450

2451

// Port on which connection will be opened to the instance to health check.

2452

// For HTTP and HTTP_STR_MATCH this defaults to 80 if the port is not specified.

2453

// For HTTPS and HTTPS_STR_MATCH this defaults to 443 if the port is not specified.

2454

Port *int64 `min:"1" type:"integer"`

2455

2456

// The number of seconds between the time that Route 53 gets a response from

2457

// your endpoint and the time that it sends the next health-check request.

2458

2459

// Each Route 53 health checker makes requests at this interval. Valid values

2460

// are 10 and 30. The default value is 30.

2461

RequestInterval *int64 `min:"10" type:"integer"`

2462

2463

// Path to ping on the instance to check the health. Required for HTTP, HTTPS,

2464

// HTTP_STR_MATCH, and HTTPS_STR_MATCH health checks, HTTP request is issued

2465

// to the instance on the given port and path.

2466

ResourcePath *string `type:"string"`

2467

2468

// A string to search for in the body of a health check response. Required for

2469

// HTTP_STR_MATCH and HTTPS_STR_MATCH health checks.

2470

SearchString *string `type:"string"`

2471

2472

// The type of health check to be performed. Currently supported types are TCP,

2473

// HTTP, HTTPS, HTTP_STR_MATCH, and HTTPS_STR_MATCH.

2474

Type *string `type:"string" required:"true" enum:"HealthCheckType"`

2475

2476

metadataHealthCheckConfig `json:"-" xml:"-"`

2477

}

2478

2479

type metadataHealthCheckConfig struct {

2480

SDKShapeTraits bool `type:"structure"`

2481

}

2482

2483

// String returns the string representation

2484

func (s HealthCheckConfig) String() string {

2485

return awsutil.Prettify(s)

2486

}

2487

2488

// GoString returns the string representation

2489

func (s HealthCheckConfig) GoString() string {

2490

return s.String()

2491

}

2492

2493

// A complex type that contains the IP address of a Route 53 health checker

2494

// and the reason for the health check status.

2495

type HealthCheckObservation struct {

2496

// The IP address of the Route 53 health checker that performed the health check.

2497

IPAddress *string `type:"string"`

2498

2499

// A complex type that contains information about the health check status for

2500

// the current observation.

2501

StatusReport *StatusReport `type:"structure"`

2502

2503

metadataHealthCheckObservation `json:"-" xml:"-"`

2504

}

2505

2506

type metadataHealthCheckObservation struct {

2507

SDKShapeTraits bool `type:"structure"`

2508

}

2509

2510

// String returns the string representation

2511

func (s HealthCheckObservation) String() string {

2512

return awsutil.Prettify(s)

2513

}

2514

2515

// GoString returns the string representation

2516

func (s HealthCheckObservation) GoString() string {

2517

return s.String()

2518

}

2519

2520

// A complex type that contain information about the specified hosted zone.

2521

type HostedZone struct {

2522

// A unique string that identifies the request to create the hosted zone.

2523

CallerReference *string `min:"1" type:"string" required:"true"`

2524

2525

// A complex type that contains the Comment element.

2526

Config *HostedZoneConfig `type:"structure"`

2527

2528

// The ID of the specified hosted zone.

2529

Id *string `type:"string" required:"true"`

2530

2531

// The name of the domain. This must be a fully-specified domain, for example,

2532

// www.example.com. The trailing dot is optional; Route 53 assumes that the

2533

// domain name is fully qualified. This means that Route 53 treats www.example.com

2534

// (without a trailing dot) and www.example.com. (with a trailing dot) as identical.

2535

2536

// This is the name you have registered with your DNS registrar. You should

2537

// ask your registrar to change the authoritative name servers for your domain

2538

// to the set of NameServers elements returned in DelegationSet.

2539

Name *string `type:"string" required:"true"`

2540

2541

// Total number of resource record sets in the hosted zone.

2542

ResourceRecordSetCount *int64 `type:"long"`

2543

2544

metadataHostedZone `json:"-" xml:"-"`

2545

}

2546

2547

type metadataHostedZone struct {

2548

SDKShapeTraits bool `type:"structure"`

2549

}

2550

2551

// String returns the string representation

2552

func (s HostedZone) String() string {

2553

return awsutil.Prettify(s)

2554

}

2555

2556

// GoString returns the string representation

2557

func (s HostedZone) GoString() string {

2558

return s.String()

2559

}

2560

2561

// A complex type that contains an optional comment about your hosted zone.

2562

// If you don't want to specify a comment, you can omit the HostedZoneConfig

2563

// and Comment elements from the XML document.

2564

type HostedZoneConfig struct {

2565

// An optional comment about your hosted zone. If you don't want to specify

2566

// a comment, you can omit the HostedZoneConfig and Comment elements from the

2567

// XML document.

2568

Comment *string `type:"string"`

2569

2570

// A value that indicates whether this is a private hosted zone. The value is

2571

// returned in the response; do not specify it in the request.

2572

PrivateZone *bool `type:"boolean"`

2573

2574

metadataHostedZoneConfig `json:"-" xml:"-"`

2575

}

2576

2577

type metadataHostedZoneConfig struct {

2578

SDKShapeTraits bool `type:"structure"`

2579

}

2580

2581

// String returns the string representation

2582

func (s HostedZoneConfig) String() string {

2583

return awsutil.Prettify(s)

2584

}

2585

2586

// GoString returns the string representation

2587

func (s HostedZoneConfig) GoString() string {

2588

return s.String()

2589

}

2590

2591

// The input for a ListGeoLocations request.

2592

type ListGeoLocationsInput struct {

2593

// The maximum number of geo locations you want in the response body.

2594

MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`

2595

2596

// The first continent code in the lexicographic ordering of geo locations that

2597

// you want the ListGeoLocations request to list. For non-continent geo locations,

2598

// this should be null.

2599

2600

// Valid values: AF | AN | AS | EU | OC | NA | SA

2601

2602

// Constraint: Specifying ContinentCode with either CountryCode or SubdivisionCode

2603

// returns an InvalidInput error.

2604

StartContinentCode *string `location:"querystring" locationName:"startcontinentcode" min:"2" type:"string"`

2605

2606

// The first country code in the lexicographic ordering of geo locations that

2607

// you want the ListGeoLocations request to list.

2608

2609

// The default geo location uses a * for the country code. All other country

2610

// codes follow the ISO 3166 two-character code.

2611

StartCountryCode *string `location:"querystring" locationName:"startcountrycode" min:"1" type:"string"`

2612

2613

// The first subdivision code in the lexicographic ordering of geo locations

2614

// that you want the ListGeoLocations request to list.

2615

2616

// Constraint: Specifying SubdivisionCode without CountryCode returns an InvalidInput

2617

// error.

2618

StartSubdivisionCode *string `location:"querystring" locationName:"startsubdivisioncode" min:"1" type:"string"`

2619

2620

metadataListGeoLocationsInput `json:"-" xml:"-"`

2621

}

2622

2623

type metadataListGeoLocationsInput struct {

2624

SDKShapeTraits bool `type:"structure"`

2625

}

2626

2627

// String returns the string representation

2628

func (s ListGeoLocationsInput) String() string {

2629

return awsutil.Prettify(s)

2630

}

2631

2632

// GoString returns the string representation

2633

func (s ListGeoLocationsInput) GoString() string {

2634

return s.String()

2635

}

2636

2637

// A complex type that contains information about the geo locations that are

2638

// returned by the request and information about the response.

2639

type ListGeoLocationsOutput struct {

2640

// A complex type that contains information about the geo locations that are

2641

// returned by the request.

2642

GeoLocationDetailsList []*GeoLocationDetails `locationNameList:"GeoLocationDetails" type:"list" required:"true"`

2643

2644

// A flag that indicates whether there are more geo locations to be listed.

2645

// If your results were truncated, you can make a follow-up request for the

2646

// next page of results by using the values included in the ListGeoLocationsResponse$NextContinentCode,

2647

// ListGeoLocationsResponse$NextCountryCode and ListGeoLocationsResponse$NextSubdivisionCode

2648

// elements.

2649

2650

// Valid Values: true | false

2651

IsTruncated *bool `type:"boolean" required:"true"`

2652

2653

// The maximum number of records you requested. The maximum value of MaxItems

2654

// is 100.

2655

MaxItems *string `type:"string" required:"true"`

2656

2657

// If the results were truncated, the continent code of the next geo location

2658

// in the list. This element is present only if ListGeoLocationsResponse$IsTruncated

2659

// is true and the next geo location to list is a continent location.

2660

NextContinentCode *string `min:"2" type:"string"`

2661

2662

// If the results were truncated, the country code of the next geo location

2663

// in the list. This element is present only if ListGeoLocationsResponse$IsTruncated

2664

// is true and the next geo location to list is not a continent location.

2665

NextCountryCode *string `min:"1" type:"string"`

2666

2667

// If the results were truncated, the subdivision code of the next geo location

2668

// in the list. This element is present only if ListGeoLocationsResponse$IsTruncated

2669

// is true and the next geo location has a subdivision.

2670

NextSubdivisionCode *string `min:"1" type:"string"`

2671

2672

metadataListGeoLocationsOutput `json:"-" xml:"-"`

2673

}

2674

2675

type metadataListGeoLocationsOutput struct {

2676

SDKShapeTraits bool `type:"structure"`

2677

}

2678

2679

// String returns the string representation

2680

func (s ListGeoLocationsOutput) String() string {

2681

return awsutil.Prettify(s)

2682

}

2683

2684

// GoString returns the string representation

2685

func (s ListGeoLocationsOutput) GoString() string {

2686

return s.String()

2687

}

2688

2689

// To retrieve a list of your health checks, send a GET request to the 2013-04-01/healthcheck

2690

// resource. The response to this request includes a HealthChecks element with

2691

// zero or more HealthCheck child elements. By default, the list of health checks

2692

// is displayed on a single page. You can control the length of the page that

2693

// is displayed by using the MaxItems parameter. You can use the Marker parameter

2694

// to control the health check that the list begins with.

2695

2696

// Route 53 returns a maximum of 100 items. If you set MaxItems to a value

2697

// greater than 100, Route 53 returns only the first 100.

2698

type ListHealthChecksInput struct {

2699

// If the request returned more than one page of results, submit another request

2700

// and specify the value of NextMarker from the last response in the marker

2701

// parameter to get the next page of results.

2702

Marker *string `location:"querystring" locationName:"marker" type:"string"`

2703

2704

// Specify the maximum number of health checks to return per page of results.

2705

MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`

2706

2707

metadataListHealthChecksInput `json:"-" xml:"-"`

2708

}

2709

2710

type metadataListHealthChecksInput struct {

2711

SDKShapeTraits bool `type:"structure"`

2712

}

2713

2714

// String returns the string representation

2715

func (s ListHealthChecksInput) String() string {

2716

return awsutil.Prettify(s)

2717

}

2718

2719

// GoString returns the string representation

2720

func (s ListHealthChecksInput) GoString() string {

2721

return s.String()

2722

}

2723

2724

// A complex type that contains the response for the request.

2725

type ListHealthChecksOutput struct {

2726

// A complex type that contains information about the health checks associated

2727

// with the current AWS account.

2728

HealthChecks []*HealthCheck `locationNameList:"HealthCheck" type:"list" required:"true"`

2729

2730

// A flag indicating whether there are more health checks to be listed. If your

2731

// results were truncated, you can make a follow-up request for the next page

2732

// of results by using the Marker element.

2733

2734

// Valid Values: true | false

2735

IsTruncated *bool `type:"boolean" required:"true"`

2736

2737

// If the request returned more than one page of results, submit another request

2738

// and specify the value of NextMarker from the last response in the marker

2739

// parameter to get the next page of results.

2740

Marker *string `type:"string" required:"true"`

2741

2742

// The maximum number of health checks to be included in the response body.

2743

// If the number of health checks associated with this AWS account exceeds MaxItems,

2744

// the value of ListHealthChecksResponse$IsTruncated in the response is true.

2745

// Call ListHealthChecks again and specify the value of ListHealthChecksResponse$NextMarker

2746

// in the ListHostedZonesRequest$Marker element to get the next page of results.

2747

MaxItems *string `type:"string" required:"true"`

2748

2749

// Indicates where to continue listing health checks. If ListHealthChecksResponse$IsTruncated

2750

// is true, make another request to ListHealthChecks and include the value of

2751

// the NextMarker element in the Marker element to get the next page of results.

2752

NextMarker *string `type:"string"`

2753

2754

metadataListHealthChecksOutput `json:"-" xml:"-"`

2755

}

2756

2757

type metadataListHealthChecksOutput struct {

2758

SDKShapeTraits bool `type:"structure"`

2759

}

2760

2761

// String returns the string representation

2762

func (s ListHealthChecksOutput) String() string {

2763

return awsutil.Prettify(s)

2764

}

2765

2766

// GoString returns the string representation

2767

func (s ListHealthChecksOutput) GoString() string {

2768

return s.String()

2769

}

2770

2771

// To retrieve a list of your hosted zones in lexicographic order, send a GET

2772

// request to the 2013-04-01/hostedzonesbyname resource. The response to this

2773

// request includes a HostedZones element with zero or more HostedZone child

2774

// elements lexicographically ordered by DNS name. By default, the list of hosted

2775

// zones is displayed on a single page. You can control the length of the page

2776

// that is displayed by using the MaxItems parameter. You can use the DNSName

2777

// and HostedZoneId parameters to control the hosted zone that the list begins

2778

// with.

2779

2780

// For more information about listing hosted zones, see Listing the Hosted

2781

// Zones for an AWS Account (http://docs.amazonwebservices.com/Route53/latest/DeveloperGuide/ListInfoOnHostedZone.html)

2782

// in the Amazon Route 53 Developer Guide.

2783

type ListHostedZonesByNameInput struct {

2784

// The first name in the lexicographic ordering of domain names that you want

2785

// the ListHostedZonesByNameRequest request to list.

2786

2787

// If the request returned more than one page of results, submit another request

2788

// and specify the value of NextDNSName and NextHostedZoneId from the last response

2789

// in the DNSName and HostedZoneId parameters to get the next page of results.

2790

DNSName *string `location:"querystring" locationName:"dnsname" type:"string"`

2791

2792

// If the request returned more than one page of results, submit another request

2793

// and specify the value of NextDNSName and NextHostedZoneId from the last response

2794

// in the DNSName and HostedZoneId parameters to get the next page of results.

2795

HostedZoneId *string `location:"querystring" locationName:"hostedzoneid" type:"string"`

2796

2797

// Specify the maximum number of hosted zones to return per page of results.

2798

MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`

2799

2800

metadataListHostedZonesByNameInput `json:"-" xml:"-"`

2801

}

2802

2803

type metadataListHostedZonesByNameInput struct {

2804

SDKShapeTraits bool `type:"structure"`

2805

}

2806

2807

// String returns the string representation

2808

func (s ListHostedZonesByNameInput) String() string {

2809

return awsutil.Prettify(s)

2810

}

2811

2812

// GoString returns the string representation

2813

func (s ListHostedZonesByNameInput) GoString() string {

2814

return s.String()

2815

}

2816

2817

// A complex type that contains the response for the request.

2818

type ListHostedZonesByNameOutput struct {

2819

// The DNSName value sent in the request.

2820

DNSName *string `type:"string"`

2821

2822

// The HostedZoneId value sent in the request.

2823

HostedZoneId *string `type:"string"`

2824

2825

// A complex type that contains information about the hosted zones associated

2826

// with the current AWS account.

2827

HostedZones []*HostedZone `locationNameList:"HostedZone" type:"list" required:"true"`

2828

2829

// A flag indicating whether there are more hosted zones to be listed. If your

2830

// results were truncated, you can make a follow-up request for the next page

2831

// of results by using the NextDNSName and NextHostedZoneId elements.

2832

2833

// Valid Values: true | false

2834

IsTruncated *bool `type:"boolean" required:"true"`

2835

2836

// The maximum number of hosted zones to be included in the response body. If

2837

// the number of hosted zones associated with this AWS account exceeds MaxItems,

2838

// the value of ListHostedZonesByNameResponse$IsTruncated in the response is

2839

// true. Call ListHostedZonesByName again and specify the value of ListHostedZonesByNameResponse$NextDNSName

2840

// and ListHostedZonesByNameResponse$NextHostedZoneId elements respectively

2841

// to get the next page of results.

2842

MaxItems *string `type:"string" required:"true"`

2843

2844

// If ListHostedZonesByNameResponse$IsTruncated is true, there are more hosted

2845

// zones associated with the current AWS account. To get the next page of results,

2846

// make another request to ListHostedZonesByName. Specify the value of ListHostedZonesByNameResponse$NextDNSName

2847

// in the ListHostedZonesByNameRequest$DNSName element and ListHostedZonesByNameResponse$NextHostedZoneId

2848

// in the ListHostedZonesByNameRequest$HostedZoneId element.

2849

NextDNSName *string `type:"string"`

2850

2851

// If ListHostedZonesByNameResponse$IsTruncated is true, there are more hosted

2852

// zones associated with the current AWS account. To get the next page of results,

2853

// make another request to ListHostedZonesByName. Specify the value of ListHostedZonesByNameResponse$NextDNSName

2854

// in the ListHostedZonesByNameRequest$DNSName element and ListHostedZonesByNameResponse$NextHostedZoneId

2855

// in the ListHostedZonesByNameRequest$HostedZoneId element.

2856

NextHostedZoneId *string `type:"string"`

2857

2858

metadataListHostedZonesByNameOutput `json:"-" xml:"-"`

2859

}

2860

2861

type metadataListHostedZonesByNameOutput struct {

2862

SDKShapeTraits bool `type:"structure"`

2863

}

2864

2865

// String returns the string representation

2866

func (s ListHostedZonesByNameOutput) String() string {

2867

return awsutil.Prettify(s)

2868

}

2869

2870

// GoString returns the string representation

2871

func (s ListHostedZonesByNameOutput) GoString() string {

2872

return s.String()

2873

}

2874

2875

// To retrieve a list of your hosted zones, send a GET request to the 2013-04-01/hostedzone

2876

// resource. The response to this request includes a HostedZones element with

2877

// zero or more HostedZone child elements. By default, the list of hosted zones

2878

// is displayed on a single page. You can control the length of the page that

2879

// is displayed by using the MaxItems parameter. You can use the Marker parameter

2880

// to control the hosted zone that the list begins with. For more information

2881

// about listing hosted zones, see Listing the Hosted Zones for an AWS Account

2882

// (http://docs.amazonwebservices.com/Route53/latest/DeveloperGuide/ListInfoOnHostedZone.html)

2883

// in the Amazon Route 53 Developer Guide.

2884

2885

// Route 53 returns a maximum of 100 items. If you set MaxItems to a value

2886

// greater than 100, Route 53 returns only the first 100.

2887

type ListHostedZonesInput struct {

2888

DelegationSetId *string `location:"querystring" locationName:"delegationsetid" type:"string"`

2889

2890

// If the request returned more than one page of results, submit another request

2891

// and specify the value of NextMarker from the last response in the marker

2892

// parameter to get the next page of results.

2893

Marker *string `location:"querystring" locationName:"marker" type:"string"`

2894

2895

// Specify the maximum number of hosted zones to return per page of results.

2896

MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`

2897

2898

metadataListHostedZonesInput `json:"-" xml:"-"`

2899

}

2900

2901

type metadataListHostedZonesInput struct {

2902

SDKShapeTraits bool `type:"structure"`

2903

}

2904

2905

// String returns the string representation

2906

func (s ListHostedZonesInput) String() string {

2907

return awsutil.Prettify(s)

2908

}

2909

2910

// GoString returns the string representation

2911

func (s ListHostedZonesInput) GoString() string {

2912

return s.String()

2913

}

2914

2915

// A complex type that contains the response for the request.

2916

type ListHostedZonesOutput struct {

2917

// A complex type that contains information about the hosted zones associated

2918

// with the current AWS account.

2919

HostedZones []*HostedZone `locationNameList:"HostedZone" type:"list" required:"true"`

2920

2921

// A flag indicating whether there are more hosted zones to be listed. If your

2922

// results were truncated, you can make a follow-up request for the next page

2923

// of results by using the Marker element.

2924

2925

// Valid Values: true | false

2926

IsTruncated *bool `type:"boolean" required:"true"`

2927

2928

// If the request returned more than one page of results, submit another request

2929

// and specify the value of NextMarker from the last response in the marker

2930

// parameter to get the next page of results.

2931

Marker *string `type:"string" required:"true"`

2932

2933

// The maximum number of hosted zones to be included in the response body. If

2934

// the number of hosted zones associated with this AWS account exceeds MaxItems,

2935

// the value of ListHostedZonesResponse$IsTruncated in the response is true.

2936

// Call ListHostedZones again and specify the value of ListHostedZonesResponse$NextMarker

2937

// in the ListHostedZonesRequest$Marker element to get the next page of results.

2938

MaxItems *string `type:"string" required:"true"`

2939

2940

// Indicates where to continue listing hosted zones. If ListHostedZonesResponse$IsTruncated

2941

// is true, make another request to ListHostedZones and include the value of

2942

// the NextMarker element in the Marker element to get the next page of results.

2943

NextMarker *string `type:"string"`

2944

2945

metadataListHostedZonesOutput `json:"-" xml:"-"`

2946

}

2947

2948

type metadataListHostedZonesOutput struct {

2949

SDKShapeTraits bool `type:"structure"`

2950

}

2951

2952

// String returns the string representation

2953

func (s ListHostedZonesOutput) String() string {

2954

return awsutil.Prettify(s)

2955

}

2956

2957

// GoString returns the string representation

2958

func (s ListHostedZonesOutput) GoString() string {

2959

return s.String()

2960

}

2961

2962

// The input for a ListResourceRecordSets request.

2963

type ListResourceRecordSetsInput struct {

2964

// The ID of the hosted zone that contains the resource record sets that you

2965

// want to get.

2966

HostedZoneId *string `location:"uri" locationName:"Id" type:"string" required:"true"`

2967

2968

// The maximum number of records you want in the response body.

2969

MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`

2970

2971

// Weighted resource record sets only: If results were truncated for a given

2972

// DNS name and type, specify the value of ListResourceRecordSetsResponse$NextRecordIdentifier

2973

// from the previous response to get the next resource record set that has the

2974

// current DNS name and type.

2975

StartRecordIdentifier *string `location:"querystring" locationName:"identifier" min:"1" type:"string"`

2976

2977

// The first name in the lexicographic ordering of domain names that you want

2978

// the ListResourceRecordSets request to list.

2979

StartRecordName *string `location:"querystring" locationName:"name" type:"string"`

2980

2981

// The DNS type at which to begin the listing of resource record sets.

2982

2983

// Valid values: A | AAAA | CNAME | MX | NS | PTR | SOA | SPF | SRV | TXT

2984

2985

// Values for Weighted Resource Record Sets: A | AAAA | CNAME | TXT

2986

2987

// Values for Regional Resource Record Sets: A | AAAA | CNAME | TXT

2988

2989

// Values for Alias Resource Record Sets: A | AAAA

2990

2991

// Constraint: Specifying type without specifying name returns an InvalidInput

2992

// error.

2993

StartRecordType *string `location:"querystring" locationName:"type" type:"string" enum:"RRType"`

2994

2995

metadataListResourceRecordSetsInput `json:"-" xml:"-"`

2996

}

2997

2998

type metadataListResourceRecordSetsInput struct {

2999

SDKShapeTraits bool `type:"structure"`

3000

}

3001

3002

// String returns the string representation

3003

func (s ListResourceRecordSetsInput) String() string {

3004

return awsutil.Prettify(s)

3005

}

3006

3007

// GoString returns the string representation

3008

func (s ListResourceRecordSetsInput) GoString() string {

3009

return s.String()

3010

}

3011

3012

// A complex type that contains information about the resource record sets that

3013

// are returned by the request and information about the response.

3014

type ListResourceRecordSetsOutput struct {

3015

// A flag that indicates whether there are more resource record sets to be listed.

3016

// If your results were truncated, you can make a follow-up request for the

3017

// next page of results by using the ListResourceRecordSetsResponse$NextRecordName

3018

// element.

3019

3020

// Valid Values: true | false

3021

IsTruncated *bool `type:"boolean" required:"true"`

3022

3023

// The maximum number of records you requested. The maximum value of MaxItems

3024

// is 100.

3025

MaxItems *string `type:"string" required:"true"`

3026

3027

// Weighted resource record sets only: If results were truncated for a given

3028

// DNS name and type, the value of SetIdentifier for the next resource record

3029

// set that has the current DNS name and type.

3030

NextRecordIdentifier *string `min:"1" type:"string"`

3031

3032

// If the results were truncated, the name of the next record in the list. This

3033

// element is present only if ListResourceRecordSetsResponse$IsTruncated is

3034

// true.

3035

NextRecordName *string `type:"string"`

3036

3037

// If the results were truncated, the type of the next record in the list. This

3038

// element is present only if ListResourceRecordSetsResponse$IsTruncated is

3039

// true.

3040

NextRecordType *string `type:"string" enum:"RRType"`

3041

3042

// A complex type that contains information about the resource record sets that

3043

// are returned by the request.

3044

ResourceRecordSets []*ResourceRecordSet `locationNameList:"ResourceRecordSet" type:"list" required:"true"`

3045

3046

metadataListResourceRecordSetsOutput `json:"-" xml:"-"`

3047

}

3048

3049

type metadataListResourceRecordSetsOutput struct {

3050

SDKShapeTraits bool `type:"structure"`

3051

}

3052

3053

// String returns the string representation

3054

func (s ListResourceRecordSetsOutput) String() string {

3055

return awsutil.Prettify(s)

3056

}

3057

3058

// GoString returns the string representation

3059

func (s ListResourceRecordSetsOutput) GoString() string {

3060

return s.String()

3061

}

3062

3063

// To retrieve a list of your reusable delegation sets, send a GET request to

3064

// the 2013-04-01/delegationset resource. The response to this request includes

3065

// a DelegationSets element with zero or more DelegationSet child elements.

3066

// By default, the list of reusable delegation sets is displayed on a single

3067

// page. You can control the length of the page that is displayed by using the

3068

// MaxItems parameter. You can use the Marker parameter to control the delegation

3069

// set that the list begins with.

3070

3071

// Route 53 returns a maximum of 100 items. If you set MaxItems to a value

3072

// greater than 100, Route 53 returns only the first 100.

3073

type ListReusableDelegationSetsInput struct {

3074

// If the request returned more than one page of results, submit another request

3075

// and specify the value of NextMarker from the last response in the marker

3076

// parameter to get the next page of results.

3077

Marker *string `location:"querystring" locationName:"marker" type:"string"`

3078

3079

// Specify the maximum number of reusable delegation sets to return per page

3080

// of results.

3081

MaxItems *string `location:"querystring" locationName:"maxitems" type:"string"`

3082

3083

metadataListReusableDelegationSetsInput `json:"-" xml:"-"`

3084

}

3085

3086

type metadataListReusableDelegationSetsInput struct {

3087

SDKShapeTraits bool `type:"structure"`

3088

}

3089

3090

// String returns the string representation

3091

func (s ListReusableDelegationSetsInput) String() string {

3092

return awsutil.Prettify(s)

3093

}

3094

3095

// GoString returns the string representation

3096

func (s ListReusableDelegationSetsInput) GoString() string {

3097

return s.String()

3098

}

3099

3100

// A complex type that contains the response for the request.

3101

type ListReusableDelegationSetsOutput struct {

3102

// A complex type that contains information about the reusable delegation sets

3103

// associated with the current AWS account.

3104

DelegationSets []*DelegationSet `locationNameList:"DelegationSet" type:"list" required:"true"`

3105

3106

// A flag indicating whether there are more reusable delegation sets to be listed.

3107

// If your results were truncated, you can make a follow-up request for the

3108

// next page of results by using the Marker element.

3109

3110

// Valid Values: true | false

3111

IsTruncated *bool `type:"boolean" required:"true"`

3112

3113

// If the request returned more than one page of results, submit another request

3114

// and specify the value of NextMarker from the last response in the marker

3115

// parameter to get the next page of results.

3116

Marker *string `type:"string" required:"true"`

3117

3118

// The maximum number of reusable delegation sets to be included in the response

3119

// body. If the number of reusable delegation sets associated with this AWS

3120

// account exceeds MaxItems, the value of ListReusablDelegationSetsResponse$IsTruncated

3121

// in the response is true. Call ListReusableDelegationSets again and specify

3122

// the value of ListReusableDelegationSetsResponse$NextMarker in the ListReusableDelegationSetsRequest$Marker

3123

// element to get the next page of results.

3124

MaxItems *string `type:"string" required:"true"`

3125

3126

// Indicates where to continue listing reusable delegation sets. If ListReusableDelegationSetsResponse$IsTruncated

3127

// is true, make another request to ListReusableDelegationSets and include the

3128

// value of the NextMarker element in the Marker element to get the next page

3129

// of results.

3130

NextMarker *string `type:"string"`

3131

3132

metadataListReusableDelegationSetsOutput `json:"-" xml:"-"`

3133

}

3134

3135

type metadataListReusableDelegationSetsOutput struct {

3136

SDKShapeTraits bool `type:"structure"`

3137

}

3138

3139

// String returns the string representation

3140

func (s ListReusableDelegationSetsOutput) String() string {

3141

return awsutil.Prettify(s)

3142

}

3143

3144

// GoString returns the string representation

3145

func (s ListReusableDelegationSetsOutput) GoString() string {

3146

return s.String()

3147

}

3148

3149

// A complex type containing information about a request for a list of the tags

3150

// that are associated with an individual resource.

3151

type ListTagsForResourceInput struct {

3152

// The ID of the resource for which you want to retrieve tags.

3153

ResourceId *string `location:"uri" locationName:"ResourceId" type:"string" required:"true"`

3154

3155

// The type of the resource.

3156

3157

// - The resource type for health checks is healthcheck.

3158

3159

// - The resource type for hosted zones is hostedzone.

3160

ResourceType *string `location:"uri" locationName:"ResourceType" type:"string" required:"true" enum:"TagResourceType"`

3161

3162

metadataListTagsForResourceInput `json:"-" xml:"-"`

3163

}

3164

3165

type metadataListTagsForResourceInput struct {

3166

SDKShapeTraits bool `type:"structure"`

3167

}

3168

3169

// String returns the string representation

3170

func (s ListTagsForResourceInput) String() string {

3171

return awsutil.Prettify(s)

3172

}

3173

3174

// GoString returns the string representation

3175

func (s ListTagsForResourceInput) GoString() string {

3176

return s.String()

3177

}

3178

3179

// A complex type containing tags for the specified resource.

3180

type ListTagsForResourceOutput struct {

3181

// A ResourceTagSet containing tags associated with the specified resource.

3182

ResourceTagSet *ResourceTagSet `type:"structure" required:"true"`

3183

3184

metadataListTagsForResourceOutput `json:"-" xml:"-"`

3185

}

3186

3187

type metadataListTagsForResourceOutput struct {

3188

SDKShapeTraits bool `type:"structure"`

3189

}

3190

3191

// String returns the string representation

3192

func (s ListTagsForResourceOutput) String() string {

3193

return awsutil.Prettify(s)

3194

}

3195

3196

// GoString returns the string representation

3197

func (s ListTagsForResourceOutput) GoString() string {

3198

return s.String()

3199

}

3200

3201

// A complex type containing information about a request for a list of the tags

3202

// that are associated with up to 10 specified resources.

3203

type ListTagsForResourcesInput struct {

3204

// A complex type that contains the ResourceId element for each resource for

3205

// which you want to get a list of tags.

3206

ResourceIds []*string `locationNameList:"ResourceId" min:"1" type:"list" required:"true"`

3207

3208

// The type of the resources.

3209

3210

// - The resource type for health checks is healthcheck.

3211

3212

// - The resource type for hosted zones is hostedzone.

3213

ResourceType *string `location:"uri" locationName:"ResourceType" type:"string" required:"true" enum:"TagResourceType"`

3214

3215

metadataListTagsForResourcesInput `json:"-" xml:"-"`

3216

}

3217

3218

type metadataListTagsForResourcesInput struct {

3219

SDKShapeTraits bool `locationName:"ListTagsForResourcesRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

3220

}

3221

3222

// String returns the string representation

3223

func (s ListTagsForResourcesInput) String() string {

3224

return awsutil.Prettify(s)

3225

}

3226

3227

// GoString returns the string representation

3228

func (s ListTagsForResourcesInput) GoString() string {

3229

return s.String()

3230

}

3231

3232

// A complex type containing tags for the specified resources.

3233

type ListTagsForResourcesOutput struct {

3234

// A list of ResourceTagSets containing tags associated with the specified resources.

3235

ResourceTagSets []*ResourceTagSet `locationNameList:"ResourceTagSet" type:"list" required:"true"`

3236

3237

metadataListTagsForResourcesOutput `json:"-" xml:"-"`

3238

}

3239

3240

type metadataListTagsForResourcesOutput struct {

3241

SDKShapeTraits bool `type:"structure"`

3242

}

3243

3244

// String returns the string representation

3245

func (s ListTagsForResourcesOutput) String() string {

3246

return awsutil.Prettify(s)

3247

}

3248

3249

// GoString returns the string representation

3250

func (s ListTagsForResourcesOutput) GoString() string {

3251

return s.String()

3252

}

3253

3254

// A complex type that contains the value of the Value element for the current

3255

// resource record set.

3256

type ResourceRecord struct {

3257

// The value of the Value element for the current resource record set.

3258

Value *string `type:"string" required:"true"`

3259

3260

metadataResourceRecord `json:"-" xml:"-"`

3261

}

3262

3263

type metadataResourceRecord struct {

3264

SDKShapeTraits bool `type:"structure"`

3265

}

3266

3267

// String returns the string representation

3268

func (s ResourceRecord) String() string {

3269

return awsutil.Prettify(s)

3270

}

3271

3272

// GoString returns the string representation

3273

func (s ResourceRecord) GoString() string {

3274

return s.String()

3275

}

3276

3277

// A complex type that contains information about the current resource record

3278

// set.

3279

type ResourceRecordSet struct {

3280

// Alias resource record sets only: Information about the AWS resource to which

3281

// you are redirecting traffic.

3282

AliasTarget *AliasTarget `type:"structure"`

3283

3284

// Failover resource record sets only: Among resource record sets that have

3285

// the same combination of DNS name and type, a value that indicates whether

3286

// the current resource record set is a primary or secondary resource record

3287

// set. A failover set may contain at most one resource record set marked as

3288

// primary and one resource record set marked as secondary. A resource record

3289

// set marked as primary will be returned if any of the following are true:

3290

// (1) an associated health check is passing, (2) if the resource record set

3291

// is an alias with the evaluate target health and at least one target resource

3292

// record set is healthy, (3) both the primary and secondary resource record

3293

// set are failing health checks or (4) there is no secondary resource record

3294

// set. A secondary resource record set will be returned if: (1) the primary

3295

// is failing a health check and either the secondary is passing a health check

3296

// or has no associated health check, or (2) there is no primary resource record

3297

// set.

3298

3299

// Valid values: PRIMARY | SECONDARY

3300

Failover *string `type:"string" enum:"ResourceRecordSetFailover"`

3301

3302

// Geo location resource record sets only: Among resource record sets that have

3303

// the same combination of DNS name and type, a value that specifies the geo

3304

// location for the current resource record set.

3305

GeoLocation *GeoLocation `type:"structure"`

3306

3307

// Health Check resource record sets only, not required for alias resource record

3308

// sets: An identifier that is used to identify health check associated with

3309

// the resource record set.

3310

HealthCheckId *string `type:"string"`

3311

3312

// The domain name of the current resource record set.

3313

Name *string `type:"string" required:"true"`

3314

3315

// Latency-based resource record sets only: Among resource record sets that

3316

// have the same combination of DNS name and type, a value that specifies the

3317

// AWS region for the current resource record set.

3318

Region *string `min:"1" type:"string" enum:"ResourceRecordSetRegion"`

3319

3320

// A complex type that contains the resource records for the current resource

3321

// record set.

3322

ResourceRecords []*ResourceRecord `locationNameList:"ResourceRecord" min:"1" type:"list"`

3323

3324

// Weighted, Latency, Geo, and Failover resource record sets only: An identifier

3325

// that differentiates among multiple resource record sets that have the same

3326

// combination of DNS name and type.

3327

SetIdentifier *string `min:"1" type:"string"`

3328

3329

// The cache time to live for the current resource record set.

3330

TTL *int64 `type:"long"`

3331

3332

// The type of the current resource record set.

3333

Type *string `type:"string" required:"true" enum:"RRType"`

3334

3335

// Weighted resource record sets only: Among resource record sets that have

3336

// the same combination of DNS name and type, a value that determines what portion

3337

// of traffic for the current resource record set is routed to the associated

3338

// location.

3339

Weight *int64 `type:"long"`

3340

3341

metadataResourceRecordSet `json:"-" xml:"-"`

3342

}

3343

3344

type metadataResourceRecordSet struct {

3345

SDKShapeTraits bool `type:"structure"`

3346

}

3347

3348

// String returns the string representation

3349

func (s ResourceRecordSet) String() string {

3350

return awsutil.Prettify(s)

3351

}

3352

3353

// GoString returns the string representation

3354

func (s ResourceRecordSet) GoString() string {

3355

return s.String()

3356

}

3357

3358

// A complex type containing a resource and its associated tags.

3359

type ResourceTagSet struct {

3360

// The ID for the specified resource.

3361

ResourceId *string `type:"string"`

3362

3363

// The type of the resource.

3364

3365

// - The resource type for health checks is healthcheck.

3366

3367

// - The resource type for hosted zones is hostedzone.

3368

ResourceType *string `type:"string" enum:"TagResourceType"`

3369

3370

// The tags associated with the specified resource.

3371

Tags []*Tag `locationNameList:"Tag" min:"1" type:"list"`

3372

3373

metadataResourceTagSet `json:"-" xml:"-"`

3374

}

3375

3376

type metadataResourceTagSet struct {

3377

SDKShapeTraits bool `type:"structure"`

3378

}

3379

3380

// String returns the string representation

3381

func (s ResourceTagSet) String() string {

3382

return awsutil.Prettify(s)

3383

}

3384

3385

// GoString returns the string representation

3386

func (s ResourceTagSet) GoString() string {

3387

return s.String()

3388

}

3389

3390

// A complex type that contains information about the health check status for

3391

// the current observation.

3392

type StatusReport struct {

3393

// The date and time the health check status was observed, in the format YYYY-MM-DDThh:mm:ssZ,

3394

// as specified in the ISO 8601 standard (for example, 2009-11-19T19:37:58Z).

3395

// The Z after the time indicates that the time is listed in Coordinated Universal

3396

// Time (UTC), which is synonymous with Greenwich Mean Time in this context.

3397

CheckedTime *time.Time `type:"timestamp" timestampFormat:"iso8601"`

3398

3399

// The observed health check status.

3400

Status *string `type:"string"`

3401

3402

metadataStatusReport `json:"-" xml:"-"`

3403

}

3404

3405

type metadataStatusReport struct {

3406

SDKShapeTraits bool `type:"structure"`

3407

}

3408

3409

// String returns the string representation

3410

func (s StatusReport) String() string {

3411

return awsutil.Prettify(s)

3412

}

3413

3414

// GoString returns the string representation

3415

func (s StatusReport) GoString() string {

3416

return s.String()

3417

}

3418

3419

// A single tag containing a key and value.

3420

type Tag struct {

3421

// The key for a Tag.

3422

Key *string `type:"string"`

3423

3424

// The value for a Tag.

3425

Value *string `type:"string"`

3426

3427

metadataTag `json:"-" xml:"-"`

3428

}

3429

3430

type metadataTag struct {

3431

SDKShapeTraits bool `type:"structure"`

3432

}

3433

3434

// String returns the string representation

3435

func (s Tag) String() string {

3436

return awsutil.Prettify(s)

3437

}

3438

3439

// GoString returns the string representation

3440

func (s Tag) GoString() string {

3441

return s.String()

3442

}

3443

3444

// >A complex type that contains information about the request to update a health

3445

// check.

3446

type UpdateHealthCheckInput struct {

3447

// For a specified parent health check, a list of HealthCheckId values for the

3448

// associated child health checks.

3449

3450

// Specify this value only if you want to change it.

3451

ChildHealthChecks []*string `locationNameList:"ChildHealthCheck" type:"list"`

3452

3453

// The number of consecutive health checks that an endpoint must pass or fail

3454

// for Route 53 to change the current status of the endpoint from unhealthy

3455

// to healthy or vice versa.

3456

3457

// Valid values are integers between 1 and 10. For more information, see "How

3458

// Amazon Route 53 Determines Whether an Endpoint Is Healthy" in the Amazon

3459

// Route 53 Developer Guide.

3460

3461

// Specify this value only if you want to change it.

3462

FailureThreshold *int64 `min:"1" type:"integer"`

3463

3464

// Fully qualified domain name of the instance to be health checked.

3465

3466

// Specify this value only if you want to change it.

3467

FullyQualifiedDomainName *string `type:"string"`

3468

3469

// The ID of the health check to update.

3470

HealthCheckId *string `location:"uri" locationName:"HealthCheckId" type:"string" required:"true"`

3471

3472

// Optional. When you specify a health check version, Route 53 compares this

3473

// value with the current value in the health check, which prevents you from

3474

// updating the health check when the versions don't match. Using HealthCheckVersion

3475

// lets you prevent overwriting another change to the health check.

3476

HealthCheckVersion *int64 `min:"1" type:"long"`

3477

3478

// The minimum number of child health checks that must be healthy for Route

3479

// 53 to consider the parent health check to be healthy. Valid values are integers

3480

// between 0 and 256, inclusive.

3481

3482

// Specify this value only if you want to change it.

3483

HealthThreshold *int64 `type:"integer"`

3484

3485

// The IP address of the resource that you want to check.

3486

3487

// Specify this value only if you want to change it.

3488

IPAddress *string `type:"string"`

3489

3490

// A boolean value that indicates whether the status of health check should

3491

// be inverted. For example, if a health check is healthy but Inverted is True,

3492

// then Route 53 considers the health check to be unhealthy.

3493

3494

// Specify this value only if you want to change it.

3495

Inverted *bool `type:"boolean"`

3496

3497

// The port on which you want Route 53 to open a connection to perform health

3498

// checks.

3499

3500

// Specify this value only if you want to change it.

3501

Port *int64 `min:"1" type:"integer"`

3502

3503

// The path that you want Amazon Route 53 to request when performing health

3504

// checks. The path can be any value for which your endpoint will return an

3505

// HTTP status code of 2xx or 3xx when the endpoint is healthy, for example

3506

// the file /docs/route53-health-check.html.

3507

3508

// Specify this value only if you want to change it.

3509

ResourcePath *string `type:"string"`

3510

3511

// If the value of Type is HTTP_STR_MATCH or HTTP_STR_MATCH, the string that

3512

// you want Route 53 to search for in the response body from the specified resource.

3513

// If the string appears in the response body, Route 53 considers the resource

3514

// healthy.

3515

3516

// Specify this value only if you want to change it.

3517

SearchString *string `type:"string"`

3518

3519

metadataUpdateHealthCheckInput `json:"-" xml:"-"`

3520

}

3521

3522

type metadataUpdateHealthCheckInput struct {

3523

SDKShapeTraits bool `locationName:"UpdateHealthCheckRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

3524

}

3525

3526

// String returns the string representation

3527

func (s UpdateHealthCheckInput) String() string {

3528

return awsutil.Prettify(s)

3529

}

3530

3531

// GoString returns the string representation

3532

func (s UpdateHealthCheckInput) GoString() string {

3533

return s.String()

3534

}

3535

3536

type UpdateHealthCheckOutput struct {

3537

// A complex type that contains identifying information about the health check.

3538

HealthCheck *HealthCheck `type:"structure" required:"true"`

3539

3540

metadataUpdateHealthCheckOutput `json:"-" xml:"-"`

3541

}

3542

3543

type metadataUpdateHealthCheckOutput struct {

3544

SDKShapeTraits bool `type:"structure"`

3545

}

3546

3547

// String returns the string representation

3548

func (s UpdateHealthCheckOutput) String() string {

3549

return awsutil.Prettify(s)

3550

}

3551

3552

// GoString returns the string representation

3553

func (s UpdateHealthCheckOutput) GoString() string {

3554

return s.String()

3555

}

3556

3557

// A complex type that contains information about the request to update a hosted

3558

// zone comment.

3559

type UpdateHostedZoneCommentInput struct {

3560

// A comment about your hosted zone.

3561

Comment *string `type:"string"`

3562

3563

// The ID of the hosted zone you want to update.

3564

Id *string `location:"uri" locationName:"Id" type:"string" required:"true"`

3565

3566

metadataUpdateHostedZoneCommentInput `json:"-" xml:"-"`

3567

}

3568

3569

type metadataUpdateHostedZoneCommentInput struct {

3570

SDKShapeTraits bool `locationName:"UpdateHostedZoneCommentRequest" type:"structure" xmlURI:"https://route53.amazonaws.com/doc/2013-04-01/"`

3571

}

3572

3573

// String returns the string representation

3574

func (s UpdateHostedZoneCommentInput) String() string {

3575

return awsutil.Prettify(s)

3576

}

3577

3578

// GoString returns the string representation

3579

func (s UpdateHostedZoneCommentInput) GoString() string {

3580

return s.String()

3581

}

3582

3583

// A complex type containing information about the specified hosted zone after

3584

// the update.

3585

type UpdateHostedZoneCommentOutput struct {

3586

// A complex type that contain information about the specified hosted zone.

3587

HostedZone *HostedZone `type:"structure" required:"true"`

3588

3589

metadataUpdateHostedZoneCommentOutput `json:"-" xml:"-"`

3590

}

3591

3592

type metadataUpdateHostedZoneCommentOutput struct {

3593

SDKShapeTraits bool `type:"structure"`

3594

}

3595

3596

// String returns the string representation

3597

func (s UpdateHostedZoneCommentOutput) String() string {

3598

return awsutil.Prettify(s)

3599

}

3600

3601

// GoString returns the string representation

3602

func (s UpdateHostedZoneCommentOutput) GoString() string {

3603

return s.String()

3604

}

3605

3606

type VPC struct {

3607

// A VPC ID

3608

VPCId *string `type:"string"`

3609

3610

VPCRegion *string `min:"1" type:"string" enum:"VPCRegion"`

3611

3612

metadataVPC `json:"-" xml:"-"`

3613

}

3614

3615

type metadataVPC struct {

3616

SDKShapeTraits bool `type:"structure"`

3617

}

3618

3619

// String returns the string representation

3620

func (s VPC) String() string {

3621

return awsutil.Prettify(s)

3622

}

3623

3624

// GoString returns the string representation

3625

func (s VPC) GoString() string {

3626

return s.String()

3627

}

3628

3629

const (

3630

// @enum ChangeAction

3631

ChangeActionCreate = "CREATE"

3632

// @enum ChangeAction

3633

ChangeActionDelete = "DELETE"

3634

// @enum ChangeAction

3635

ChangeActionUpsert = "UPSERT"

3636

)

3637

3638

const (

3639

// @enum ChangeStatus

3640

ChangeStatusPending = "PENDING"

3641

// @enum ChangeStatus

3642

ChangeStatusInsync = "INSYNC"

3643

)

3644

3645

const (

3646

// @enum HealthCheckType

3647

HealthCheckTypeHttp = "HTTP"

3648

// @enum HealthCheckType

3649

HealthCheckTypeHttps = "HTTPS"

3650

// @enum HealthCheckType

3651

HealthCheckTypeHttpStrMatch = "HTTP_STR_MATCH"

3652

// @enum HealthCheckType

3653

HealthCheckTypeHttpsStrMatch = "HTTPS_STR_MATCH"

3654

// @enum HealthCheckType

3655

HealthCheckTypeTcp = "TCP"

3656

// @enum HealthCheckType

3657

HealthCheckTypeCalculated = "CALCULATED"

3658

)

3659

3660

const (

3661

// @enum RRType

3662

RRTypeSoa = "SOA"

3663

// @enum RRType

3664

RRTypeA = "A"

3665

// @enum RRType

3666

RRTypeTxt = "TXT"

3667

// @enum RRType

3668

RRTypeNs = "NS"

3669

// @enum RRType

3670

RRTypeCname = "CNAME"

3671

// @enum RRType

3672

RRTypeMx = "MX"

3673

// @enum RRType

3674

RRTypePtr = "PTR"

3675

// @enum RRType

3676

RRTypeSrv = "SRV"

3677

// @enum RRType

3678

RRTypeSpf = "SPF"

3679

// @enum RRType

3680

RRTypeAaaa = "AAAA"

3681

)

3682

3683

const (

3684

// @enum ResourceRecordSetFailover

3685

ResourceRecordSetFailoverPrimary = "PRIMARY"

3686

// @enum ResourceRecordSetFailover

3687

ResourceRecordSetFailoverSecondary = "SECONDARY"

3688

)

3689

3690

const (

3691

// @enum ResourceRecordSetRegion

3692

ResourceRecordSetRegionUsEast1 = "us-east-1"

3693

// @enum ResourceRecordSetRegion

3694

ResourceRecordSetRegionUsWest1 = "us-west-1"

3695

// @enum ResourceRecordSetRegion

3696

ResourceRecordSetRegionUsWest2 = "us-west-2"

3697

// @enum ResourceRecordSetRegion

3698

ResourceRecordSetRegionEuWest1 = "eu-west-1"

3699

// @enum ResourceRecordSetRegion

3700

ResourceRecordSetRegionEuCentral1 = "eu-central-1"

3701

// @enum ResourceRecordSetRegion

3702

ResourceRecordSetRegionApSoutheast1 = "ap-southeast-1"

3703

// @enum ResourceRecordSetRegion

3704

ResourceRecordSetRegionApSoutheast2 = "ap-southeast-2"

3705

// @enum ResourceRecordSetRegion

3706

ResourceRecordSetRegionApNortheast1 = "ap-northeast-1"

3707

// @enum ResourceRecordSetRegion

3708

ResourceRecordSetRegionSaEast1 = "sa-east-1"

3709

// @enum ResourceRecordSetRegion

3710

ResourceRecordSetRegionCnNorth1 = "cn-north-1"

3711

)

3712

3713

const (

3714

// @enum TagResourceType

3715

TagResourceTypeHealthcheck = "healthcheck"

3716

// @enum TagResourceType

3717

TagResourceTypeHostedzone = "hostedzone"

3718

)

3719

3720

const (

3721

// @enum VPCRegion

3722

VPCRegionUsEast1 = "us-east-1"

3723

// @enum VPCRegion

3724

VPCRegionUsWest1 = "us-west-1"

3725

// @enum VPCRegion

3726

VPCRegionUsWest2 = "us-west-2"

3727

// @enum VPCRegion

3728

VPCRegionEuWest1 = "eu-west-1"

3729

// @enum VPCRegion

3730

VPCRegionEuCentral1 = "eu-central-1"

3731

// @enum VPCRegion

3732

VPCRegionApSoutheast1 = "ap-southeast-1"

3733

// @enum VPCRegion

3734

VPCRegionApSoutheast2 = "ap-southeast-2"

3735

// @enum VPCRegion

3736

VPCRegionApNortheast1 = "ap-northeast-1"

3737

// @enum VPCRegion

3738

VPCRegionSaEast1 = "sa-east-1"

3739

// @enum VPCRegion

3740

VPCRegionCnNorth1 = "cn-north-1"

3741

)

Older »