vendor: update all dependencies
This commit is contained in:
Nick Craig-Wood
parent
3f0789e2db
commit
08021c4636
2474 changed files with 435818 additions and 282709 deletions
803
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/api-2.json
generated
vendored
803
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/api-2.json
generated
vendored
|
|
@ -1,803 +0,0 @@
|
|||
{
|
||||
"version":"2.0",
|
||||
"metadata":{
|
||||
"apiVersion":"2011-12-05",
|
||||
"endpointPrefix":"dynamodb",
|
||||
"jsonVersion":"1.0",
|
||||
"protocol":"json",
|
||||
"serviceAbbreviation":"DynamoDB",
|
||||
"serviceFullName":"Amazon DynamoDB",
|
||||
"serviceId":"DynamoDB",
|
||||
"signatureVersion":"v4",
|
||||
"targetPrefix":"DynamoDB_20111205",
|
||||
"uid":"dynamodb-2011-12-05"
|
||||
},
|
||||
"operations":{
|
||||
"BatchGetItem":{
|
||||
"name":"BatchGetItem",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"BatchGetItemInput"},
|
||||
"output":{"shape":"BatchGetItemOutput"},
|
||||
"errors":[
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"BatchWriteItem":{
|
||||
"name":"BatchWriteItem",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"BatchWriteItemInput"},
|
||||
"output":{"shape":"BatchWriteItemOutput"},
|
||||
"errors":[
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"CreateTable":{
|
||||
"name":"CreateTable",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"CreateTableInput"},
|
||||
"output":{"shape":"CreateTableOutput"},
|
||||
"errors":[
|
||||
{"shape":"ResourceInUseException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"DeleteItem":{
|
||||
"name":"DeleteItem",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"DeleteItemInput"},
|
||||
"output":{"shape":"DeleteItemOutput"},
|
||||
"errors":[
|
||||
{"shape":"ConditionalCheckFailedException"},
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"DeleteTable":{
|
||||
"name":"DeleteTable",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"DeleteTableInput"},
|
||||
"output":{"shape":"DeleteTableOutput"},
|
||||
"errors":[
|
||||
{"shape":"ResourceInUseException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"DescribeTable":{
|
||||
"name":"DescribeTable",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"DescribeTableInput"},
|
||||
"output":{"shape":"DescribeTableOutput"},
|
||||
"errors":[
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"GetItem":{
|
||||
"name":"GetItem",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"GetItemInput"},
|
||||
"output":{"shape":"GetItemOutput"},
|
||||
"errors":[
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"ListTables":{
|
||||
"name":"ListTables",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"ListTablesInput"},
|
||||
"output":{"shape":"ListTablesOutput"},
|
||||
"errors":[
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"PutItem":{
|
||||
"name":"PutItem",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"PutItemInput"},
|
||||
"output":{"shape":"PutItemOutput"},
|
||||
"errors":[
|
||||
{"shape":"ConditionalCheckFailedException"},
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"Query":{
|
||||
"name":"Query",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"QueryInput"},
|
||||
"output":{"shape":"QueryOutput"},
|
||||
"errors":[
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"Scan":{
|
||||
"name":"Scan",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"ScanInput"},
|
||||
"output":{"shape":"ScanOutput"},
|
||||
"errors":[
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"UpdateItem":{
|
||||
"name":"UpdateItem",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"UpdateItemInput"},
|
||||
"output":{"shape":"UpdateItemOutput"},
|
||||
"errors":[
|
||||
{"shape":"ConditionalCheckFailedException"},
|
||||
{"shape":"ProvisionedThroughputExceededException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
},
|
||||
"UpdateTable":{
|
||||
"name":"UpdateTable",
|
||||
"http":{
|
||||
"method":"POST",
|
||||
"requestUri":"/"
|
||||
},
|
||||
"input":{"shape":"UpdateTableInput"},
|
||||
"output":{"shape":"UpdateTableOutput"},
|
||||
"errors":[
|
||||
{"shape":"ResourceInUseException"},
|
||||
{"shape":"ResourceNotFoundException"},
|
||||
{"shape":"LimitExceededException"},
|
||||
{"shape":"InternalServerError"}
|
||||
]
|
||||
}
|
||||
},
|
||||
"shapes":{
|
||||
"AttributeAction":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
"ADD",
|
||||
"PUT",
|
||||
"DELETE"
|
||||
]
|
||||
},
|
||||
"AttributeMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"AttributeName"},
|
||||
"value":{"shape":"AttributeValue"}
|
||||
},
|
||||
"AttributeName":{
|
||||
"type":"string",
|
||||
"max":65535
|
||||
},
|
||||
"AttributeNameList":{
|
||||
"type":"list",
|
||||
"member":{"shape":"AttributeName"},
|
||||
"min":1
|
||||
},
|
||||
"AttributeUpdates":{
|
||||
"type":"map",
|
||||
"key":{"shape":"AttributeName"},
|
||||
"value":{"shape":"AttributeValueUpdate"}
|
||||
},
|
||||
"AttributeValue":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"S":{"shape":"StringAttributeValue"},
|
||||
"N":{"shape":"NumberAttributeValue"},
|
||||
"B":{"shape":"BinaryAttributeValue"},
|
||||
"SS":{"shape":"StringSetAttributeValue"},
|
||||
"NS":{"shape":"NumberSetAttributeValue"},
|
||||
"BS":{"shape":"BinarySetAttributeValue"}
|
||||
}
|
||||
},
|
||||
"AttributeValueList":{
|
||||
"type":"list",
|
||||
"member":{"shape":"AttributeValue"}
|
||||
},
|
||||
"AttributeValueUpdate":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Value":{"shape":"AttributeValue"},
|
||||
"Action":{"shape":"AttributeAction"}
|
||||
}
|
||||
},
|
||||
"BatchGetItemInput":{
|
||||
"type":"structure",
|
||||
"required":["RequestItems"],
|
||||
"members":{
|
||||
"RequestItems":{"shape":"BatchGetRequestMap"}
|
||||
}
|
||||
},
|
||||
"BatchGetItemOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Responses":{"shape":"BatchGetResponseMap"},
|
||||
"UnprocessedKeys":{"shape":"BatchGetRequestMap"}
|
||||
}
|
||||
},
|
||||
"BatchGetRequestMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"TableName"},
|
||||
"value":{"shape":"KeysAndAttributes"},
|
||||
"max":100,
|
||||
"min":1
|
||||
},
|
||||
"BatchGetResponseMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"TableName"},
|
||||
"value":{"shape":"BatchResponse"}
|
||||
},
|
||||
"BatchResponse":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Items":{"shape":"ItemList"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"BatchWriteItemInput":{
|
||||
"type":"structure",
|
||||
"required":["RequestItems"],
|
||||
"members":{
|
||||
"RequestItems":{"shape":"BatchWriteItemRequestMap"}
|
||||
}
|
||||
},
|
||||
"BatchWriteItemOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Responses":{"shape":"BatchWriteResponseMap"},
|
||||
"UnprocessedItems":{"shape":"BatchWriteItemRequestMap"}
|
||||
}
|
||||
},
|
||||
"BatchWriteItemRequestMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"TableName"},
|
||||
"value":{"shape":"WriteRequests"},
|
||||
"max":25,
|
||||
"min":1
|
||||
},
|
||||
"BatchWriteResponse":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"BatchWriteResponseMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"TableName"},
|
||||
"value":{"shape":"BatchWriteResponse"}
|
||||
},
|
||||
"BinaryAttributeValue":{"type":"blob"},
|
||||
"BinarySetAttributeValue":{
|
||||
"type":"list",
|
||||
"member":{"shape":"BinaryAttributeValue"}
|
||||
},
|
||||
"BooleanObject":{"type":"boolean"},
|
||||
"ComparisonOperator":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
"EQ",
|
||||
"NE",
|
||||
"IN",
|
||||
"LE",
|
||||
"LT",
|
||||
"GE",
|
||||
"GT",
|
||||
"BETWEEN",
|
||||
"NOT_NULL",
|
||||
"NULL",
|
||||
"CONTAINS",
|
||||
"NOT_CONTAINS",
|
||||
"BEGINS_WITH"
|
||||
]
|
||||
},
|
||||
"Condition":{
|
||||
"type":"structure",
|
||||
"required":["ComparisonOperator"],
|
||||
"members":{
|
||||
"AttributeValueList":{"shape":"AttributeValueList"},
|
||||
"ComparisonOperator":{"shape":"ComparisonOperator"}
|
||||
}
|
||||
},
|
||||
"ConditionalCheckFailedException":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"message":{"shape":"ErrorMessage"}
|
||||
},
|
||||
"exception":true
|
||||
},
|
||||
"ConsistentRead":{"type":"boolean"},
|
||||
"ConsumedCapacityUnits":{"type":"double"},
|
||||
"CreateTableInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"KeySchema",
|
||||
"ProvisionedThroughput"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"KeySchema":{"shape":"KeySchema"},
|
||||
"ProvisionedThroughput":{"shape":"ProvisionedThroughput"}
|
||||
}
|
||||
},
|
||||
"CreateTableOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"TableDescription":{"shape":"TableDescription"}
|
||||
}
|
||||
},
|
||||
"Date":{"type":"timestamp"},
|
||||
"DeleteItemInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"Key"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"Key":{"shape":"Key"},
|
||||
"Expected":{"shape":"ExpectedAttributeMap"},
|
||||
"ReturnValues":{"shape":"ReturnValue"}
|
||||
}
|
||||
},
|
||||
"DeleteItemOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Attributes":{"shape":"AttributeMap"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"DeleteRequest":{
|
||||
"type":"structure",
|
||||
"required":["Key"],
|
||||
"members":{
|
||||
"Key":{"shape":"Key"}
|
||||
}
|
||||
},
|
||||
"DeleteTableInput":{
|
||||
"type":"structure",
|
||||
"required":["TableName"],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"}
|
||||
}
|
||||
},
|
||||
"DeleteTableOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"TableDescription":{"shape":"TableDescription"}
|
||||
}
|
||||
},
|
||||
"DescribeTableInput":{
|
||||
"type":"structure",
|
||||
"required":["TableName"],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"}
|
||||
}
|
||||
},
|
||||
"DescribeTableOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Table":{"shape":"TableDescription"}
|
||||
}
|
||||
},
|
||||
"ErrorMessage":{"type":"string"},
|
||||
"ExpectedAttributeMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"AttributeName"},
|
||||
"value":{"shape":"ExpectedAttributeValue"}
|
||||
},
|
||||
"ExpectedAttributeValue":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Value":{"shape":"AttributeValue"},
|
||||
"Exists":{"shape":"BooleanObject"}
|
||||
}
|
||||
},
|
||||
"FilterConditionMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"String"},
|
||||
"value":{"shape":"Condition"}
|
||||
},
|
||||
"GetItemInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"Key"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"Key":{"shape":"Key"},
|
||||
"AttributesToGet":{"shape":"AttributeNameList"},
|
||||
"ConsistentRead":{"shape":"ConsistentRead"}
|
||||
}
|
||||
},
|
||||
"GetItemOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Item":{"shape":"AttributeMap"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"Integer":{"type":"integer"},
|
||||
"InternalServerError":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"message":{"shape":"ErrorMessage"}
|
||||
},
|
||||
"exception":true,
|
||||
"fault":true
|
||||
},
|
||||
"ItemList":{
|
||||
"type":"list",
|
||||
"member":{"shape":"AttributeMap"}
|
||||
},
|
||||
"Key":{
|
||||
"type":"structure",
|
||||
"required":["HashKeyElement"],
|
||||
"members":{
|
||||
"HashKeyElement":{"shape":"AttributeValue"},
|
||||
"RangeKeyElement":{"shape":"AttributeValue"}
|
||||
}
|
||||
},
|
||||
"KeyList":{
|
||||
"type":"list",
|
||||
"member":{"shape":"Key"},
|
||||
"max":100,
|
||||
"min":1
|
||||
},
|
||||
"KeySchema":{
|
||||
"type":"structure",
|
||||
"required":["HashKeyElement"],
|
||||
"members":{
|
||||
"HashKeyElement":{"shape":"KeySchemaElement"},
|
||||
"RangeKeyElement":{"shape":"KeySchemaElement"}
|
||||
}
|
||||
},
|
||||
"KeySchemaAttributeName":{
|
||||
"type":"string",
|
||||
"max":255,
|
||||
"min":1
|
||||
},
|
||||
"KeySchemaElement":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"AttributeName",
|
||||
"AttributeType"
|
||||
],
|
||||
"members":{
|
||||
"AttributeName":{"shape":"KeySchemaAttributeName"},
|
||||
"AttributeType":{"shape":"ScalarAttributeType"}
|
||||
}
|
||||
},
|
||||
"KeysAndAttributes":{
|
||||
"type":"structure",
|
||||
"required":["Keys"],
|
||||
"members":{
|
||||
"Keys":{"shape":"KeyList"},
|
||||
"AttributesToGet":{"shape":"AttributeNameList"},
|
||||
"ConsistentRead":{"shape":"ConsistentRead"}
|
||||
}
|
||||
},
|
||||
"LimitExceededException":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"message":{"shape":"ErrorMessage"}
|
||||
},
|
||||
"exception":true
|
||||
},
|
||||
"ListTablesInput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"ExclusiveStartTableName":{"shape":"TableName"},
|
||||
"Limit":{"shape":"ListTablesInputLimit"}
|
||||
}
|
||||
},
|
||||
"ListTablesInputLimit":{
|
||||
"type":"integer",
|
||||
"max":100,
|
||||
"min":1
|
||||
},
|
||||
"ListTablesOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"TableNames":{"shape":"TableNameList"},
|
||||
"LastEvaluatedTableName":{"shape":"TableName"}
|
||||
}
|
||||
},
|
||||
"Long":{"type":"long"},
|
||||
"NumberAttributeValue":{"type":"string"},
|
||||
"NumberSetAttributeValue":{
|
||||
"type":"list",
|
||||
"member":{"shape":"NumberAttributeValue"}
|
||||
},
|
||||
"PositiveIntegerObject":{
|
||||
"type":"integer",
|
||||
"min":1
|
||||
},
|
||||
"PositiveLongObject":{
|
||||
"type":"long",
|
||||
"min":1
|
||||
},
|
||||
"ProvisionedThroughput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"ReadCapacityUnits",
|
||||
"WriteCapacityUnits"
|
||||
],
|
||||
"members":{
|
||||
"ReadCapacityUnits":{"shape":"PositiveLongObject"},
|
||||
"WriteCapacityUnits":{"shape":"PositiveLongObject"}
|
||||
}
|
||||
},
|
||||
"ProvisionedThroughputDescription":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"LastIncreaseDateTime":{"shape":"Date"},
|
||||
"LastDecreaseDateTime":{"shape":"Date"},
|
||||
"NumberOfDecreasesToday":{"shape":"PositiveLongObject"},
|
||||
"ReadCapacityUnits":{"shape":"PositiveLongObject"},
|
||||
"WriteCapacityUnits":{"shape":"PositiveLongObject"}
|
||||
}
|
||||
},
|
||||
"ProvisionedThroughputExceededException":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"message":{"shape":"ErrorMessage"}
|
||||
},
|
||||
"exception":true
|
||||
},
|
||||
"PutItemInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"Item"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"Item":{"shape":"PutItemInputAttributeMap"},
|
||||
"Expected":{"shape":"ExpectedAttributeMap"},
|
||||
"ReturnValues":{"shape":"ReturnValue"}
|
||||
}
|
||||
},
|
||||
"PutItemInputAttributeMap":{
|
||||
"type":"map",
|
||||
"key":{"shape":"AttributeName"},
|
||||
"value":{"shape":"AttributeValue"}
|
||||
},
|
||||
"PutItemOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Attributes":{"shape":"AttributeMap"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"PutRequest":{
|
||||
"type":"structure",
|
||||
"required":["Item"],
|
||||
"members":{
|
||||
"Item":{"shape":"PutItemInputAttributeMap"}
|
||||
}
|
||||
},
|
||||
"QueryInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"HashKeyValue"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"AttributesToGet":{"shape":"AttributeNameList"},
|
||||
"Limit":{"shape":"PositiveIntegerObject"},
|
||||
"ConsistentRead":{"shape":"ConsistentRead"},
|
||||
"Count":{"shape":"BooleanObject"},
|
||||
"HashKeyValue":{"shape":"AttributeValue"},
|
||||
"RangeKeyCondition":{"shape":"Condition"},
|
||||
"ScanIndexForward":{"shape":"BooleanObject"},
|
||||
"ExclusiveStartKey":{"shape":"Key"}
|
||||
}
|
||||
},
|
||||
"QueryOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Items":{"shape":"ItemList"},
|
||||
"Count":{"shape":"Integer"},
|
||||
"LastEvaluatedKey":{"shape":"Key"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"ResourceInUseException":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"message":{"shape":"ErrorMessage"}
|
||||
},
|
||||
"exception":true
|
||||
},
|
||||
"ResourceNotFoundException":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"message":{"shape":"ErrorMessage"}
|
||||
},
|
||||
"exception":true
|
||||
},
|
||||
"ReturnValue":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
"NONE",
|
||||
"ALL_OLD",
|
||||
"UPDATED_OLD",
|
||||
"ALL_NEW",
|
||||
"UPDATED_NEW"
|
||||
]
|
||||
},
|
||||
"ScalarAttributeType":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
"S",
|
||||
"N",
|
||||
"B"
|
||||
]
|
||||
},
|
||||
"ScanInput":{
|
||||
"type":"structure",
|
||||
"required":["TableName"],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"AttributesToGet":{"shape":"AttributeNameList"},
|
||||
"Limit":{"shape":"PositiveIntegerObject"},
|
||||
"Count":{"shape":"BooleanObject"},
|
||||
"ScanFilter":{"shape":"FilterConditionMap"},
|
||||
"ExclusiveStartKey":{"shape":"Key"}
|
||||
}
|
||||
},
|
||||
"ScanOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Items":{"shape":"ItemList"},
|
||||
"Count":{"shape":"Integer"},
|
||||
"ScannedCount":{"shape":"Integer"},
|
||||
"LastEvaluatedKey":{"shape":"Key"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"String":{"type":"string"},
|
||||
"StringAttributeValue":{"type":"string"},
|
||||
"StringSetAttributeValue":{
|
||||
"type":"list",
|
||||
"member":{"shape":"StringAttributeValue"}
|
||||
},
|
||||
"TableDescription":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"KeySchema":{"shape":"KeySchema"},
|
||||
"TableStatus":{"shape":"TableStatus"},
|
||||
"CreationDateTime":{"shape":"Date"},
|
||||
"ProvisionedThroughput":{"shape":"ProvisionedThroughputDescription"},
|
||||
"TableSizeBytes":{"shape":"Long"},
|
||||
"ItemCount":{"shape":"Long"}
|
||||
}
|
||||
},
|
||||
"TableName":{
|
||||
"type":"string",
|
||||
"max":255,
|
||||
"min":3,
|
||||
"pattern":"[a-zA-Z0-9_.-]+"
|
||||
},
|
||||
"TableNameList":{
|
||||
"type":"list",
|
||||
"member":{"shape":"TableName"}
|
||||
},
|
||||
"TableStatus":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
"CREATING",
|
||||
"UPDATING",
|
||||
"DELETING",
|
||||
"ACTIVE"
|
||||
]
|
||||
},
|
||||
"UpdateItemInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"Key",
|
||||
"AttributeUpdates"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"Key":{"shape":"Key"},
|
||||
"AttributeUpdates":{"shape":"AttributeUpdates"},
|
||||
"Expected":{"shape":"ExpectedAttributeMap"},
|
||||
"ReturnValues":{"shape":"ReturnValue"}
|
||||
}
|
||||
},
|
||||
"UpdateItemOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Attributes":{"shape":"AttributeMap"},
|
||||
"ConsumedCapacityUnits":{"shape":"ConsumedCapacityUnits"}
|
||||
}
|
||||
},
|
||||
"UpdateTableInput":{
|
||||
"type":"structure",
|
||||
"required":[
|
||||
"TableName",
|
||||
"ProvisionedThroughput"
|
||||
],
|
||||
"members":{
|
||||
"TableName":{"shape":"TableName"},
|
||||
"ProvisionedThroughput":{"shape":"ProvisionedThroughput"}
|
||||
}
|
||||
},
|
||||
"UpdateTableOutput":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"TableDescription":{"shape":"TableDescription"}
|
||||
}
|
||||
},
|
||||
"WriteRequest":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"PutRequest":{"shape":"PutRequest"},
|
||||
"DeleteRequest":{"shape":"DeleteRequest"}
|
||||
}
|
||||
},
|
||||
"WriteRequests":{
|
||||
"type":"list",
|
||||
"member":{"shape":"WriteRequest"},
|
||||
"max":25,
|
||||
"min":1
|
||||
}
|
||||
}
|
||||
}
|
||||
606
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/docs-2.json
generated
vendored
606
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/docs-2.json
generated
vendored
|
|
@ -1,606 +0,0 @@
|
|||
{
|
||||
"version": "2.0",
|
||||
"service": "<p>Amazon DynamoDB is a fast, highly scalable, highly available, cost-effective non-relational database service.</p> <p>Amazon DynamoDB removes traditional scalability limitations on data storage while maintaining low latency and predictable performance.</p>",
|
||||
"operations": {
|
||||
"BatchGetItem": "<p>Retrieves the attributes for multiple items from multiple tables using their primary keys.</p> <p>The maximum number of item attributes that can be retrieved for a single operation is 100. Also, the number of items retrieved is constrained by a 1 MB the size limit. If the response size limit is exceeded or a partial result is returned due to an internal processing failure, Amazon DynamoDB returns an <code>UnprocessedKeys</code> value so you can retry the operation starting with the next item to get.</p> <p>Amazon DynamoDB automatically adjusts the number of items returned per page to enforce this limit. For example, even if you ask to retrieve 100 items, but each individual item is 50k in size, the system returns 20 items and an appropriate <code>UnprocessedKeys</code> value so you can get the next page of results. If necessary, your application needs its own logic to assemble the pages of results into one set.</p>",
|
||||
"BatchWriteItem": "<p>Allows to execute a batch of Put and/or Delete Requests for many tables in a single call. A total of 25 requests are allowed.</p> <p>There are no transaction guarantees provided by this API. It does not allow conditional puts nor does it support return values.</p>",
|
||||
"CreateTable": "<p>Adds a new table to your account.</p> <p>The table name must be unique among those associated with the AWS Account issuing the request, and the AWS Region that receives the request (e.g. <code>us-east-1</code>).</p> <p>The <code>CreateTable</code> operation triggers an asynchronous workflow to begin creating the table. Amazon DynamoDB immediately returns the state of the table (<code>CREATING</code>) until the table is in the <code>ACTIVE</code> state. Once the table is in the <code>ACTIVE</code> state, you can perform data plane operations.</p>",
|
||||
"DeleteItem": "<p>Deletes a single item in a table by primary key.</p> <p>You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value.</p>",
|
||||
"DeleteTable": "<p>Deletes a table and all of its items.</p> <p>If the table is in the <code>ACTIVE</code> state, you can delete it. If a table is in <code>CREATING</code> or <code>UPDATING</code> states then Amazon DynamoDB returns a <code>ResourceInUseException</code>. If the specified table does not exist, Amazon DynamoDB returns a <code>ResourceNotFoundException</code>.</p>",
|
||||
"DescribeTable": "<p>Retrieves information about the table, including the current status of the table, the primary key schema and when the table was created.</p> <p>If the table does not exist, Amazon DynamoDB returns a <code>ResourceNotFoundException</code>.</p>",
|
||||
"GetItem": "<p>Retrieves a set of Attributes for an item that matches the primary key.</p> <p>The <code>GetItem</code> operation provides an eventually-consistent read by default. If eventually-consistent reads are not acceptable for your application, use <code>ConsistentRead</code>. Although this operation might take longer than a standard read, it always returns the last updated value.</p>",
|
||||
"ListTables": "<p>Retrieves a paginated list of table names created by the AWS Account of the caller in the AWS Region (e.g. <code>us-east-1</code>).</p>",
|
||||
"PutItem": "<p>Creates a new item, or replaces an old item with a new item (including all the attributes).</p> <p>If an item already exists in the specified table with the same primary key, the new item completely replaces the existing item. You can perform a conditional put (insert a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values.</p>",
|
||||
"Query": "<p>Gets the values of one or more items and its attributes by primary key (composite primary key, only).</p> <p>Narrow the scope of the query using comparison operators on the <code>RangeKeyValue</code> of the composite key. Use the <code>ScanIndexForward</code> parameter to get results in forward or reverse order by range key.</p>",
|
||||
"Scan": "<p>Retrieves one or more items and its attributes by performing a full scan of a table.</p> <p>Provide a <code>ScanFilter</code> to get more specific results.</p>",
|
||||
"UpdateItem": "<p>Edits an existing item's attributes.</p> <p>You can perform a conditional update (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values).</p>",
|
||||
"UpdateTable": "<p>Updates the provisioned throughput for the given table.</p> <p>Setting the throughput for a table helps you manage performance and is part of the Provisioned Throughput feature of Amazon DynamoDB.</p>"
|
||||
},
|
||||
"shapes": {
|
||||
"AttributeAction": {
|
||||
"base": "<p>The type of action for an item update operation. Only use the add action for numbers or sets; the specified value is added to the existing value. If a set of values is specified, the values are added to the existing set. Adds the specified attribute. If the attribute exists, it is replaced by the new value. If no value is specified, this removes the attribute and its value. If a set of values is specified, then the values in the specified set are removed from the old set.</p>",
|
||||
"refs": {
|
||||
"AttributeValueUpdate$Action": null
|
||||
}
|
||||
},
|
||||
"AttributeMap": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"DeleteItemOutput$Attributes": "<p>If the <code>ReturnValues</code> parameter is provided as <code>ALL_OLD</code> in the request, Amazon DynamoDB returns an array of attribute name-value pairs (essentially, the deleted item). Otherwise, the response contains an empty set.</p>",
|
||||
"GetItemOutput$Item": "<p>Contains the requested attributes.</p>",
|
||||
"ItemList$member": null,
|
||||
"PutItemOutput$Attributes": "<p>Attribute values before the put operation, but only if the <code>ReturnValues</code> parameter is specified as <code>ALL_OLD</code> in the request.</p>",
|
||||
"UpdateItemOutput$Attributes": "<p>A map of attribute name-value pairs, but only if the <code>ReturnValues</code> parameter is specified as something other than <code>NONE</code> in the request.</p>"
|
||||
}
|
||||
},
|
||||
"AttributeName": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeMap$key": null,
|
||||
"AttributeNameList$member": null,
|
||||
"AttributeUpdates$key": null,
|
||||
"ExpectedAttributeMap$key": null,
|
||||
"PutItemInputAttributeMap$key": null
|
||||
}
|
||||
},
|
||||
"AttributeNameList": {
|
||||
"base": "<p>List of <code>Attribute</code> names. If attribute names are not specified then all attributes will be returned. If some attributes are not found, they will not appear in the result.</p>",
|
||||
"refs": {
|
||||
"GetItemInput$AttributesToGet": null,
|
||||
"KeysAndAttributes$AttributesToGet": null,
|
||||
"QueryInput$AttributesToGet": null,
|
||||
"ScanInput$AttributesToGet": null
|
||||
}
|
||||
},
|
||||
"AttributeUpdates": {
|
||||
"base": "<p>Map of attribute name to the new value and action for the update. The attribute names specify the attributes to modify, and cannot contain any primary key attributes.</p>",
|
||||
"refs": {
|
||||
"UpdateItemInput$AttributeUpdates": null
|
||||
}
|
||||
},
|
||||
"AttributeValue": {
|
||||
"base": "<p>AttributeValue can be <code>String</code>, <code>Number</code>, <code>Binary</code>, <code>StringSet</code>, <code>NumberSet</code>, <code>BinarySet</code>.</p>",
|
||||
"refs": {
|
||||
"AttributeMap$value": null,
|
||||
"AttributeValueList$member": null,
|
||||
"AttributeValueUpdate$Value": null,
|
||||
"ExpectedAttributeValue$Value": "<p>Specify whether or not a value already exists and has a specific content for the attribute name-value pair.</p>",
|
||||
"Key$HashKeyElement": "<p>A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be <code>String</code>, <code>Number</code>, <code>StringSet</code>, <code>NumberSet</code>.</p>",
|
||||
"Key$RangeKeyElement": "<p>A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be <code>String</code>, <code>Number</code>, <code>StringSet</code>, <code>NumberSet</code>.</p>",
|
||||
"PutItemInputAttributeMap$value": null,
|
||||
"QueryInput$HashKeyValue": "<p>Attribute value of the hash component of the composite primary key.</p>"
|
||||
}
|
||||
},
|
||||
"AttributeValueList": {
|
||||
"base": "<p>A list of attribute values to be used with a comparison operator for a scan or query operation. For comparisons that require more than one value, such as a <code>BETWEEN</code> comparison, the AttributeValueList contains two attribute values and the comparison operator.</p>",
|
||||
"refs": {
|
||||
"Condition$AttributeValueList": null
|
||||
}
|
||||
},
|
||||
"AttributeValueUpdate": {
|
||||
"base": "<p>Specifies the attribute to update and how to perform the update. Possible values: <code>PUT</code> (default), <code>ADD</code> or <code>DELETE</code>.</p>",
|
||||
"refs": {
|
||||
"AttributeUpdates$value": null
|
||||
}
|
||||
},
|
||||
"BatchGetItemInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"BatchGetItemOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"BatchGetRequestMap": {
|
||||
"base": "<p>A map of the table name and corresponding items to get by primary key. While requesting items, each table name can be invoked only once per operation.</p>",
|
||||
"refs": {
|
||||
"BatchGetItemInput$RequestItems": null,
|
||||
"BatchGetItemOutput$UnprocessedKeys": "<p>Contains a map of tables and their respective keys that were not processed with the current response, possibly due to reaching a limit on the response size. The <code>UnprocessedKeys</code> value is in the same form as a <code>RequestItems</code> parameter (so the value can be provided directly to a subsequent <code>BatchGetItem</code> operation). For more information, see the above <code>RequestItems</code> parameter.</p>"
|
||||
}
|
||||
},
|
||||
"BatchGetResponseMap": {
|
||||
"base": "<p>Table names and the respective item attributes from the tables.</p>",
|
||||
"refs": {
|
||||
"BatchGetItemOutput$Responses": null
|
||||
}
|
||||
},
|
||||
"BatchResponse": {
|
||||
"base": "<p>The item attributes from a response in a specific table, along with the read resources consumed on the table during the request.</p>",
|
||||
"refs": {
|
||||
"BatchGetResponseMap$value": null
|
||||
}
|
||||
},
|
||||
"BatchWriteItemInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"BatchWriteItemOutput": {
|
||||
"base": "<p>A container for <code>BatchWriteItem</code> response</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"BatchWriteItemRequestMap": {
|
||||
"base": "<p>A map of table name to list-of-write-requests.</p> <p>Key: The table name corresponding to the list of requests</p> <p>Value: Essentially a list of request items. Each request item could contain either a <code>PutRequest</code> or <code>DeleteRequest</code>. Never both.</p>",
|
||||
"refs": {
|
||||
"BatchWriteItemInput$RequestItems": "<p>A map of table name to list-of-write-requests. Used as input to the <code>BatchWriteItem</code> API call</p>",
|
||||
"BatchWriteItemOutput$UnprocessedItems": "<p>The Items which we could not successfully process in a <code>BatchWriteItem</code> call is returned as <code>UnprocessedItems</code></p>"
|
||||
}
|
||||
},
|
||||
"BatchWriteResponse": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"BatchWriteResponseMap$value": null
|
||||
}
|
||||
},
|
||||
"BatchWriteResponseMap": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"BatchWriteItemOutput$Responses": "<p>The response object as a result of <code>BatchWriteItem</code> call. This is essentially a map of table name to <code>ConsumedCapacityUnits</code>.</p>"
|
||||
}
|
||||
},
|
||||
"BinaryAttributeValue": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeValue$B": "<p>Binary attributes are sequences of unsigned bytes.</p>",
|
||||
"BinarySetAttributeValue$member": null
|
||||
}
|
||||
},
|
||||
"BinarySetAttributeValue": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeValue$BS": "<p>A set of binary attributes.</p>"
|
||||
}
|
||||
},
|
||||
"BooleanObject": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"ExpectedAttributeValue$Exists": "<p>Specify whether or not a value already exists for the attribute name-value pair.</p>",
|
||||
"QueryInput$Count": "<p>If set to <code>true</code>, Amazon DynamoDB returns a total number of items that match the query parameters, instead of a list of the matching items and their attributes. Do not set <code>Count</code> to <code>true</code> while providing a list of <code>AttributesToGet</code>, otherwise Amazon DynamoDB returns a validation error.</p>",
|
||||
"QueryInput$ScanIndexForward": "<p>Specifies forward or backward traversal of the index. Amazon DynamoDB returns results reflecting the requested order, determined by the range key. The default value is <code>true</code> (forward).</p>",
|
||||
"ScanInput$Count": "<p>If set to <code>true</code>, Amazon DynamoDB returns a total number of items for the <code>Scan</code> operation, even if the operation has no matching items for the assigned filter. Do not set <code>Count</code> to <code>true</code> while providing a list of <code>AttributesToGet</code>, otherwise Amazon DynamoDB returns a validation error.</p>"
|
||||
}
|
||||
},
|
||||
"ComparisonOperator": {
|
||||
"base": "<p>A comparison operator is an enumeration of several operations:</p> <ul> <li><code>EQ</code> for <em>equal</em>.</li> <li><code>NE</code> for <em>not equal</em>.</li> <li><code>IN</code> checks for exact matches.</li> <li><code>LE</code> for <em>less than or equal to</em>.</li> <li><code>LT</code> for <em>less than</em>.</li> <li><code>GE</code> for <em>greater than or equal to</em>.</li> <li><code>GT</code> for <em>greater than</em>.</li> <li><code>BETWEEN</code> for <em>between</em>.</li> <li><code>NOT_NULL</code> for <em>exists</em>.</li> <li><code>NULL</code> for <em>not exists</em>.</li> <li><code>CONTAINS</code> for substring or value in a set.</li> <li><code>NOT_CONTAINS</code> for absence of a substring or absence of a value in a set.</li> <li><code>BEGINS_WITH</code> for a substring prefix.</li> </ul> <p>Scan operations support all available comparison operators.</p> <p>Query operations support a subset of the available comparison operators: EQ, LE, LT, GE, GT, BETWEEN, and BEGINS_WITH.</p>",
|
||||
"refs": {
|
||||
"Condition$ComparisonOperator": null
|
||||
}
|
||||
},
|
||||
"Condition": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"FilterConditionMap$value": null,
|
||||
"QueryInput$RangeKeyCondition": "<p>A container for the attribute values and comparison operators to use for the query.</p>"
|
||||
}
|
||||
},
|
||||
"ConditionalCheckFailedException": {
|
||||
"base": "<p>This exception is thrown when an expected value does not match what was found in the system.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ConsistentRead": {
|
||||
"base": "<p>If set to <code>true</code>, then a consistent read is issued. Otherwise eventually-consistent is used.</p>",
|
||||
"refs": {
|
||||
"GetItemInput$ConsistentRead": null,
|
||||
"KeysAndAttributes$ConsistentRead": null,
|
||||
"QueryInput$ConsistentRead": null
|
||||
}
|
||||
},
|
||||
"ConsumedCapacityUnits": {
|
||||
"base": "<p>The number of Capacity Units of the provisioned throughput of the table consumed during the operation. <code>GetItem</code>, <code>BatchGetItem</code>, <code>BatchWriteItem</code>, <code>Query</code>, and <code>Scan</code> operations consume <code>ReadCapacityUnits</code>, while <code>PutItem</code>, <code>UpdateItem</code>, and <code>DeleteItem</code> operations consume <code>WriteCapacityUnits</code>.</p>",
|
||||
"refs": {
|
||||
"BatchResponse$ConsumedCapacityUnits": null,
|
||||
"BatchWriteResponse$ConsumedCapacityUnits": null,
|
||||
"DeleteItemOutput$ConsumedCapacityUnits": null,
|
||||
"GetItemOutput$ConsumedCapacityUnits": null,
|
||||
"PutItemOutput$ConsumedCapacityUnits": null,
|
||||
"QueryOutput$ConsumedCapacityUnits": null,
|
||||
"ScanOutput$ConsumedCapacityUnits": null,
|
||||
"UpdateItemOutput$ConsumedCapacityUnits": null
|
||||
}
|
||||
},
|
||||
"CreateTableInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"CreateTableOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"Date": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"ProvisionedThroughputDescription$LastIncreaseDateTime": null,
|
||||
"ProvisionedThroughputDescription$LastDecreaseDateTime": null,
|
||||
"TableDescription$CreationDateTime": null
|
||||
}
|
||||
},
|
||||
"DeleteItemInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"DeleteItemOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"DeleteRequest": {
|
||||
"base": "<p>A container for a Delete BatchWrite request</p>",
|
||||
"refs": {
|
||||
"WriteRequest$DeleteRequest": null
|
||||
}
|
||||
},
|
||||
"DeleteTableInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"DeleteTableOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"DescribeTableInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"DescribeTableOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ErrorMessage": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"ConditionalCheckFailedException$message": null,
|
||||
"InternalServerError$message": null,
|
||||
"LimitExceededException$message": null,
|
||||
"ProvisionedThroughputExceededException$message": null,
|
||||
"ResourceInUseException$message": null,
|
||||
"ResourceNotFoundException$message": null
|
||||
}
|
||||
},
|
||||
"ExpectedAttributeMap": {
|
||||
"base": "<p>Designates an attribute for a conditional modification. The <code>Expected</code> parameter allows you to provide an attribute name, and whether or not Amazon DynamoDB should check to see if the attribute has a particular value before modifying it.</p>",
|
||||
"refs": {
|
||||
"DeleteItemInput$Expected": null,
|
||||
"PutItemInput$Expected": null,
|
||||
"UpdateItemInput$Expected": null
|
||||
}
|
||||
},
|
||||
"ExpectedAttributeValue": {
|
||||
"base": "<p>Allows you to provide an attribute name, and whether or not Amazon DynamoDB should check to see if the attribute value already exists; or if the attribute value exists and has a particular value before changing it.</p>",
|
||||
"refs": {
|
||||
"ExpectedAttributeMap$value": null
|
||||
}
|
||||
},
|
||||
"FilterConditionMap": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"ScanInput$ScanFilter": "<p>Evaluates the scan results and returns only the desired values.</p>"
|
||||
}
|
||||
},
|
||||
"GetItemInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"GetItemOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"Integer": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"QueryOutput$Count": "<p>Number of items in the response.</p>",
|
||||
"ScanOutput$Count": "<p>Number of items in the response.</p>",
|
||||
"ScanOutput$ScannedCount": "<p>Number of items in the complete scan before any filters are applied. A high <code>ScannedCount</code> value with few, or no, <code>Count</code> results indicates an inefficient <code>Scan</code> operation.</p>"
|
||||
}
|
||||
},
|
||||
"InternalServerError": {
|
||||
"base": "<p>This exception is thrown when the service has a problem when trying to process the request.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ItemList": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"BatchResponse$Items": null,
|
||||
"QueryOutput$Items": null,
|
||||
"ScanOutput$Items": null
|
||||
}
|
||||
},
|
||||
"Key": {
|
||||
"base": "<p>The primary key that uniquely identifies each item in a table. A primary key can be a one attribute (hash) primary key or a two attribute (hash-and-range) primary key.</p>",
|
||||
"refs": {
|
||||
"DeleteItemInput$Key": null,
|
||||
"DeleteRequest$Key": "<p>The item's key to be delete</p>",
|
||||
"GetItemInput$Key": null,
|
||||
"KeyList$member": null,
|
||||
"QueryInput$ExclusiveStartKey": "<p>Primary key of the item from which to continue an earlier query. An earlier query might provide this value as the <code>LastEvaluatedKey</code> if that query operation was interrupted before completing the query; either because of the result set size or the <code>Limit</code> parameter. The <code>LastEvaluatedKey</code> can be passed back in a new query request to continue the operation from that point.</p>",
|
||||
"QueryOutput$LastEvaluatedKey": "<p>Primary key of the item where the query operation stopped, inclusive of the previous result set. Use this value to start a new operation excluding this value in the new request. The <code>LastEvaluatedKey</code> is null when the entire query result set is complete (i.e. the operation processed the \"last page\").</p>",
|
||||
"ScanInput$ExclusiveStartKey": "<p>Primary key of the item from which to continue an earlier scan. An earlier scan might provide this value if that scan operation was interrupted before scanning the entire table; either because of the result set size or the <code>Limit</code> parameter. The <code>LastEvaluatedKey</code> can be passed back in a new scan request to continue the operation from that point.</p>",
|
||||
"ScanOutput$LastEvaluatedKey": "<p>Primary key of the item where the scan operation stopped. Provide this value in a subsequent scan operation to continue the operation from that point. The <code>LastEvaluatedKey</code> is null when the entire scan result set is complete (i.e. the operation processed the \"last page\").</p>",
|
||||
"UpdateItemInput$Key": null
|
||||
}
|
||||
},
|
||||
"KeyList": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"KeysAndAttributes$Keys": null
|
||||
}
|
||||
},
|
||||
"KeySchema": {
|
||||
"base": "<p>The KeySchema identifies the primary key as a one attribute primary key (hash) or a composite two attribute (hash-and-range) primary key. Single attribute primary keys have one index value: a <code>HashKeyElement</code>. A composite hash-and-range primary key contains two attribute values: a <code>HashKeyElement</code> and a <code>RangeKeyElement</code>.</p>",
|
||||
"refs": {
|
||||
"CreateTableInput$KeySchema": null,
|
||||
"TableDescription$KeySchema": null
|
||||
}
|
||||
},
|
||||
"KeySchemaAttributeName": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"KeySchemaElement$AttributeName": "<p>The <code>AttributeName</code> of the <code>KeySchemaElement</code>.</p>"
|
||||
}
|
||||
},
|
||||
"KeySchemaElement": {
|
||||
"base": "<p><code>KeySchemaElement</code> is the primary key (hash or hash-and-range) structure for the table.</p>",
|
||||
"refs": {
|
||||
"KeySchema$HashKeyElement": "<p>A hash key element is treated as the primary key, and can be a string or a number. Single attribute primary keys have one index value. The value can be <code>String</code>, <code>Number</code>, <code>StringSet</code>, <code>NumberSet</code>.</p>",
|
||||
"KeySchema$RangeKeyElement": "<p>A range key element is treated as a secondary key (used in conjunction with the primary key), and can be a string or a number, and is only used for hash-and-range primary keys. The value can be <code>String</code>, <code>Number</code>, <code>StringSet</code>, <code>NumberSet</code>.</p>"
|
||||
}
|
||||
},
|
||||
"KeysAndAttributes": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"BatchGetRequestMap$value": null
|
||||
}
|
||||
},
|
||||
"LimitExceededException": {
|
||||
"base": "<p>This exception is thrown when the subscriber exceeded the limits on the number of objects or operations.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ListTablesInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ListTablesInputLimit": {
|
||||
"base": "<p>A number of maximum table names to return.</p>",
|
||||
"refs": {
|
||||
"ListTablesInput$Limit": null
|
||||
}
|
||||
},
|
||||
"ListTablesOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"Long": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"TableDescription$TableSizeBytes": null,
|
||||
"TableDescription$ItemCount": null
|
||||
}
|
||||
},
|
||||
"NumberAttributeValue": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeValue$N": "<p>Numbers are positive or negative exact-value decimals and integers. A number can have up to 38 digits precision and can be between 10^-128 to 10^+126.</p>",
|
||||
"NumberSetAttributeValue$member": null
|
||||
}
|
||||
},
|
||||
"NumberSetAttributeValue": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeValue$NS": "<p>A set of numbers.</p>"
|
||||
}
|
||||
},
|
||||
"PositiveIntegerObject": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"QueryInput$Limit": "<p>The maximum number of items to return. If Amazon DynamoDB hits this limit while querying the table, it stops the query and returns the matching values up to the limit, and a <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the query. Also, if the result set size exceeds 1MB before Amazon DynamoDB hits this limit, it stops the query and returns the matching values, and a <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the query.</p>",
|
||||
"ScanInput$Limit": "<p>The maximum number of items to return. If Amazon DynamoDB hits this limit while scanning the table, it stops the scan and returns the matching values up to the limit, and a <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the scan. Also, if the scanned data set size exceeds 1 MB before Amazon DynamoDB hits this limit, it stops the scan and returns the matching values up to the limit, and a <code>LastEvaluatedKey</code> to apply in a subsequent operation to continue the scan.</p>"
|
||||
}
|
||||
},
|
||||
"PositiveLongObject": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"ProvisionedThroughput$ReadCapacityUnits": "<p><code>ReadCapacityUnits</code> are in terms of strictly consistent reads, assuming items of 1k. 2k items require twice the <code>ReadCapacityUnits</code>. Eventually-consistent reads only require half the <code>ReadCapacityUnits</code> of stirctly consistent reads.</p>",
|
||||
"ProvisionedThroughput$WriteCapacityUnits": "<p><code>WriteCapacityUnits</code> are in terms of strictly consistent reads, assuming items of 1k. 2k items require twice the <code>WriteCapacityUnits</code>.</p>",
|
||||
"ProvisionedThroughputDescription$NumberOfDecreasesToday": null,
|
||||
"ProvisionedThroughputDescription$ReadCapacityUnits": null,
|
||||
"ProvisionedThroughputDescription$WriteCapacityUnits": null
|
||||
}
|
||||
},
|
||||
"ProvisionedThroughput": {
|
||||
"base": "<p>Provisioned throughput reserves the required read and write resources for your table in terms of <code>ReadCapacityUnits</code> and <code>WriteCapacityUnits</code>. Values for provisioned throughput depend upon your expected read/write rates, item size, and consistency. Provide the expected number of read and write operations, assuming an item size of 1k and strictly consistent reads. For 2k item size, double the value. For 3k, triple the value, etc. Eventually-consistent reads consume half the resources of strictly consistent reads.</p>",
|
||||
"refs": {
|
||||
"CreateTableInput$ProvisionedThroughput": null,
|
||||
"UpdateTableInput$ProvisionedThroughput": null
|
||||
}
|
||||
},
|
||||
"ProvisionedThroughputDescription": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"TableDescription$ProvisionedThroughput": null
|
||||
}
|
||||
},
|
||||
"ProvisionedThroughputExceededException": {
|
||||
"base": "<p>This exception is thrown when the level of provisioned throughput defined for the table is exceeded.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"PutItemInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"PutItemInputAttributeMap": {
|
||||
"base": "<p>A map of the attributes for the item, and must include the primary key values that define the item. Other attribute name-value pairs can be provided for the item.</p>",
|
||||
"refs": {
|
||||
"PutItemInput$Item": null,
|
||||
"PutRequest$Item": "<p>The item to put</p>"
|
||||
}
|
||||
},
|
||||
"PutItemOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"PutRequest": {
|
||||
"base": "<p>A container for a Put BatchWrite request</p>",
|
||||
"refs": {
|
||||
"WriteRequest$PutRequest": null
|
||||
}
|
||||
},
|
||||
"QueryInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"QueryOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ResourceInUseException": {
|
||||
"base": "<p>This exception is thrown when the resource which is being attempted to be changed is in use.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ResourceNotFoundException": {
|
||||
"base": "<p>This exception is thrown when the resource which is being attempted to be changed is in use.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ReturnValue": {
|
||||
"base": "<p>Use this parameter if you want to get the attribute name-value pairs before or after they are modified. For <code>PUT</code> operations, the possible parameter values are <code>NONE</code> (default) or <code>ALL_OLD</code>. For update operations, the possible parameter values are <code>NONE</code> (default) or <code>ALL_OLD</code>, <code>UPDATED_OLD</code>, <code>ALL_NEW</code> or <code>UPDATED_NEW</code>.</p> <ul> <li><code>NONE</code>: Nothing is returned.</li> <li><code>ALL_OLD</code>: Returns the attributes of the item as they were before the operation.</li> <li><code>UPDATED_OLD</code>: Returns the values of the updated attributes, only, as they were before the operation.</li> <li><code>ALL_NEW</code>: Returns all the attributes and their new values after the operation.</li> <li><code>UPDATED_NEW</code>: Returns the values of the updated attributes, only, as they are after the operation.</li> </ul>",
|
||||
"refs": {
|
||||
"DeleteItemInput$ReturnValues": null,
|
||||
"PutItemInput$ReturnValues": null,
|
||||
"UpdateItemInput$ReturnValues": null
|
||||
}
|
||||
},
|
||||
"ScalarAttributeType": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"KeySchemaElement$AttributeType": "<p>The <code>AttributeType</code> of the <code>KeySchemaElement</code> which can be a <code>String</code> or a <code>Number</code>.</p>"
|
||||
}
|
||||
},
|
||||
"ScanInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"ScanOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"String": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"FilterConditionMap$key": null
|
||||
}
|
||||
},
|
||||
"StringAttributeValue": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeValue$S": "<p>Strings are Unicode with UTF-8 binary encoding. The maximum size is limited by the size of the primary key (1024 bytes as a range part of a key or 2048 bytes as a single part hash key) or the item size (64k).</p>",
|
||||
"StringSetAttributeValue$member": null
|
||||
}
|
||||
},
|
||||
"StringSetAttributeValue": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"AttributeValue$SS": "<p>A set of strings.</p>"
|
||||
}
|
||||
},
|
||||
"TableDescription": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"CreateTableOutput$TableDescription": null,
|
||||
"DeleteTableOutput$TableDescription": null,
|
||||
"DescribeTableOutput$Table": null,
|
||||
"UpdateTableOutput$TableDescription": null
|
||||
}
|
||||
},
|
||||
"TableName": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"BatchGetRequestMap$key": null,
|
||||
"BatchGetResponseMap$key": null,
|
||||
"BatchWriteItemRequestMap$key": null,
|
||||
"BatchWriteResponseMap$key": null,
|
||||
"CreateTableInput$TableName": "<p>The name of the table you want to create. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"DeleteItemInput$TableName": "<p>The name of the table in which you want to delete an item. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"DeleteTableInput$TableName": "<p>The name of the table you want to delete. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"DescribeTableInput$TableName": "<p>The name of the table you want to describe. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"GetItemInput$TableName": "<p>The name of the table in which you want to get an item. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"ListTablesInput$ExclusiveStartTableName": "<p>The name of the table that starts the list. If you already ran a <code>ListTables</code> operation and received a <code>LastEvaluatedTableName</code> value in the response, use that value here to continue the list.</p>",
|
||||
"ListTablesOutput$LastEvaluatedTableName": "<p>The name of the last table in the current list. Use this value as the <code>ExclusiveStartTableName</code> in a new request to continue the list until all the table names are returned. If this value is null, all table names have been returned.</p>",
|
||||
"PutItemInput$TableName": "<p>The name of the table in which you want to put an item. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"QueryInput$TableName": "<p>The name of the table in which you want to query. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"ScanInput$TableName": "<p>The name of the table in which you want to scan. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"TableDescription$TableName": "<p>The name of the table being described.</p>",
|
||||
"TableNameList$member": null,
|
||||
"UpdateItemInput$TableName": "<p>The name of the table in which you want to update an item. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>",
|
||||
"UpdateTableInput$TableName": "<p>The name of the table you want to update. Allowed characters are <code>a-z</code>, <code>A-Z</code>, <code>0-9</code>, <code>_</code> (underscore), <code>-</code> (hyphen) and <code>.</code> (period).</p>"
|
||||
}
|
||||
},
|
||||
"TableNameList": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"ListTablesOutput$TableNames": null
|
||||
}
|
||||
},
|
||||
"TableStatus": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"TableDescription$TableStatus": null
|
||||
}
|
||||
},
|
||||
"UpdateItemInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"UpdateItemOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"UpdateTableInput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"UpdateTableOutput": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
"WriteRequest": {
|
||||
"base": "<p>This structure is a Union of PutRequest and DeleteRequest. It can contain exactly one of <code>PutRequest</code> or <code>DeleteRequest</code>. Never Both. This is enforced in the code.</p>",
|
||||
"refs": {
|
||||
"WriteRequests$member": null
|
||||
}
|
||||
},
|
||||
"WriteRequests": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"BatchWriteItemRequestMap$value": null
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
5
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/examples-1.json
generated
vendored
5
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/examples-1.json
generated
vendored
|
|
@ -1,5 +0,0 @@
|
|||
{
|
||||
"version": "1.0",
|
||||
"examples": {
|
||||
}
|
||||
}
|
||||
26
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/paginators-1.json
generated
vendored
26
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/paginators-1.json
generated
vendored
|
|
@ -1,26 +0,0 @@
|
|||
{
|
||||
"pagination": {
|
||||
"BatchGetItem": {
|
||||
"input_token": "RequestItems",
|
||||
"output_token": "UnprocessedKeys"
|
||||
},
|
||||
"ListTables": {
|
||||
"input_token": "ExclusiveStartTableName",
|
||||
"limit_key": "Limit",
|
||||
"output_token": "LastEvaluatedTableName",
|
||||
"result_key": "TableNames"
|
||||
},
|
||||
"Query": {
|
||||
"input_token": "ExclusiveStartKey",
|
||||
"limit_key": "Limit",
|
||||
"output_token": "LastEvaluatedKey",
|
||||
"result_key": "Items"
|
||||
},
|
||||
"Scan": {
|
||||
"input_token": "ExclusiveStartKey",
|
||||
"limit_key": "Limit",
|
||||
"output_token": "LastEvaluatedKey",
|
||||
"result_key": "Items"
|
||||
}
|
||||
}
|
||||
}
|
||||
35
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/waiters-2.json
generated
vendored
35
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2011-12-05/waiters-2.json
generated
vendored
|
|
@ -1,35 +0,0 @@
|
|||
{
|
||||
"version": 2,
|
||||
"waiters": {
|
||||
"TableExists": {
|
||||
"delay": 20,
|
||||
"operation": "DescribeTable",
|
||||
"maxAttempts": 25,
|
||||
"acceptors": [
|
||||
{
|
||||
"expected": "ACTIVE",
|
||||
"matcher": "path",
|
||||
"state": "success",
|
||||
"argument": "Table.TableStatus"
|
||||
},
|
||||
{
|
||||
"expected": "ResourceNotFoundException",
|
||||
"matcher": "error",
|
||||
"state": "retry"
|
||||
}
|
||||
]
|
||||
},
|
||||
"TableNotExists": {
|
||||
"delay": 20,
|
||||
"operation": "DescribeTable",
|
||||
"maxAttempts": 25,
|
||||
"acceptors": [
|
||||
{
|
||||
"expected": "ResourceNotFoundException",
|
||||
"matcher": "error",
|
||||
"state": "success"
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
12
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2012-08-10/api-2.json
generated
vendored
12
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2012-08-10/api-2.json
generated
vendored
|
|
@ -1290,6 +1290,7 @@
|
|||
"type":"list",
|
||||
"member":{"shape":"AttributeMap"}
|
||||
},
|
||||
"KMSMasterKeyArn":{"type":"string"},
|
||||
"Key":{
|
||||
"type":"map",
|
||||
"key":{"shape":"AttributeName"},
|
||||
|
|
@ -1855,7 +1856,9 @@
|
|||
"SSEDescription":{
|
||||
"type":"structure",
|
||||
"members":{
|
||||
"Status":{"shape":"SSEStatus"}
|
||||
"Status":{"shape":"SSEStatus"},
|
||||
"SSEType":{"shape":"SSEType"},
|
||||
"KMSMasterKeyArn":{"shape":"KMSMasterKeyArn"}
|
||||
}
|
||||
},
|
||||
"SSEEnabled":{"type":"boolean"},
|
||||
|
|
@ -1875,6 +1878,13 @@
|
|||
"DISABLED"
|
||||
]
|
||||
},
|
||||
"SSEType":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
"AES256",
|
||||
"KMS"
|
||||
]
|
||||
},
|
||||
"ScalarAttributeType":{
|
||||
"type":"string",
|
||||
"enum":[
|
||||
|
|
|
|||
22
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2012-08-10/docs-2.json
generated
vendored
22
vendor/github.com/aws/aws-sdk-go/models/apis/dynamodb/2012-08-10/docs-2.json
generated
vendored
|
|
@ -5,7 +5,7 @@
|
|||
"BatchGetItem": "<p>The <code>BatchGetItem</code> operation returns the attributes of one or more items from one or more tables. You identify requested items by primary key.</p> <p>A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items. <code>BatchGetItem</code> will return a partial result if the response size limit is exceeded, the table's provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned, the operation returns a value for <code>UnprocessedKeys</code>. You can use this value to retry the operation starting with the next item to get.</p> <important> <p>If you request more than 100 items <code>BatchGetItem</code> will return a <code>ValidationException</code> with the message \"Too many items requested for the BatchGetItem call\".</p> </important> <p>For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns an appropriate <code>UnprocessedKeys</code> value so you can get the next page of results. If desired, your application can include its own logic to assemble the pages of results into one data set.</p> <p>If <i>none</i> of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then <code>BatchGetItem</code> will return a <code>ProvisionedThroughputExceededException</code>. If <i>at least one</i> of the items is successfully processed, then <code>BatchGetItem</code> completes successfully, while returning the keys of the unread items in <code>UnprocessedKeys</code>.</p> <important> <p>If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, <i>we strongly recommend that you use an exponential backoff algorithm</i>. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed.</p> <p>For more information, see <a href=\"http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations\">Batch Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </important> <p>By default, <code>BatchGetItem</code> performs eventually consistent reads on every table in the request. If you want strongly consistent reads instead, you can set <code>ConsistentRead</code> to <code>true</code> for any or all tables.</p> <p>In order to minimize response latency, <code>BatchGetItem</code> retrieves items in parallel.</p> <p>When designing your application, keep in mind that DynamoDB does not return items in any particular order. To help parse the response by item, include the primary key values for the items in your request in the <code>ProjectionExpression</code> parameter.</p> <p>If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the minimum read capacity units according to the type of read. For more information, see <a href=\"http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations\">Capacity Units Calculations</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>",
|
||||
"BatchWriteItem": "<p>The <code>BatchWriteItem</code> operation puts or deletes multiple items in one or more tables. A single call to <code>BatchWriteItem</code> can write up to 16 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 400 KB.</p> <note> <p> <code>BatchWriteItem</code> cannot update items. To update items, use the <code>UpdateItem</code> action.</p> </note> <p>The individual <code>PutItem</code> and <code>DeleteItem</code> operations specified in <code>BatchWriteItem</code> are atomic; however <code>BatchWriteItem</code> as a whole is not. If any requested operations fail because the table's provisioned throughput is exceeded or an internal processing failure occurs, the failed operations are returned in the <code>UnprocessedItems</code> response parameter. You can investigate and optionally resend the requests. Typically, you would call <code>BatchWriteItem</code> in a loop. Each iteration would check for unprocessed items and submit a new <code>BatchWriteItem</code> request with those unprocessed items until all items have been processed.</p> <p>Note that if <i>none</i> of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then <code>BatchWriteItem</code> will return a <code>ProvisionedThroughputExceededException</code>.</p> <important> <p>If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, <i>we strongly recommend that you use an exponential backoff algorithm</i>. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed.</p> <p>For more information, see <a href=\"http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations\">Batch Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> </important> <p>With <code>BatchWriteItem</code>, you can efficiently write or delete large amounts of data, such as from Amazon Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve performance with these large-scale operations, <code>BatchWriteItem</code> does not behave in the same way as individual <code>PutItem</code> and <code>DeleteItem</code> calls would. For example, you cannot specify conditions on individual put and delete requests, and <code>BatchWriteItem</code> does not return deleted items in the response.</p> <p>If you use a programming language that supports concurrency, you can use threads to write items in parallel. Your application must include the necessary logic to manage the threads. With languages that don't support threading, you must update or delete the specified items one at a time. In both situations, <code>BatchWriteItem</code> performs the specified put and delete operations in parallel, giving you the power of the thread pool approach without having to introduce complexity into your application.</p> <p>Parallel processing reduces latency, but each specified put and delete request consumes the same number of write capacity units whether it is processed in parallel or not. Delete operations on nonexistent items consume one write capacity unit.</p> <p>If one or more of the following is true, DynamoDB rejects the entire batch write operation:</p> <ul> <li> <p>One or more tables specified in the <code>BatchWriteItem</code> request does not exist.</p> </li> <li> <p>Primary key attributes specified on an item in the request do not match those in the corresponding table's primary key schema.</p> </li> <li> <p>You try to perform multiple operations on the same item in the same <code>BatchWriteItem</code> request. For example, you cannot put and delete the same item in the same <code>BatchWriteItem</code> request. </p> </li> <li> <p> Your request contains at least two items with identical hash and range keys (which essentially is two put operations). </p> </li> <li> <p>There are more than 25 requests in the batch.</p> </li> <li> <p>Any individual item in a batch exceeds 400 KB.</p> </li> <li> <p>The total request size exceeds 16 MB.</p> </li> </ul>",
|
||||
"CreateBackup": "<p>Creates a backup for an existing table.</p> <p> Each time you create an On-Demand Backup, the entire table data is backed up. There is no limit to the number of on-demand backups that can be taken. </p> <p> When you create an On-Demand Backup, a time marker of the request is cataloged, and the backup is created asynchronously, by applying all changes until the time of the request to the last full table snapshot. Backup requests are processed instantaneously and become available for restore within minutes. </p> <p>You can call <code>CreateBackup</code> at a maximum rate of 50 times per second.</p> <p>All backups in DynamoDB work without consuming any provisioned throughput on the table.</p> <p> If you submit a backup request on 2018-12-14 at 14:25:00, the backup is guaranteed to contain all data committed to the table up to 14:24:00, and data committed after 14:26:00 will not be. The backup may or may not contain data modifications made between 14:24:00 and 14:26:00. On-Demand Backup does not support causal consistency. </p> <p> Along with data, the following are also included on the backups: </p> <ul> <li> <p>Global secondary indexes (GSIs)</p> </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> <p>Streams</p> </li> <li> <p>Provisioned read and write capacity</p> </li> </ul>",
|
||||
"CreateGlobalTable": "<p>Creates a global table from an existing table. A global table creates a replication relationship between two or more DynamoDB tables with the same table name in the provided regions. </p> <p> Tables can only be added as the replicas of a global table group under the following conditions: </p> <ul> <li> <p> The tables must have the same name. </p> </li> <li> <p> The tables must contain no items. </p> </li> <li> <p> The tables must have the same hash key and sort key (if present). </p> </li> <li> <p> The tables must have DynamoDB Streams enabled (NEW_AND_OLD_IMAGES). </p> </li> <li> <p> The tables must have same provisioned and maximum write capacity units. </p> </li> </ul> <p> If global secondary indexes are specified, then the following conditions must also be met: </p> <ul> <li> <p> The global secondary indexes must have the same name. </p> </li> <li> <p> The global secondary indexes must have the same hash key and sort key (if present). </p> </li> <li> <p> The global secondary indexes must have the same provisioned and maximum write capacity units. </p> </li> </ul>",
|
||||
"CreateGlobalTable": "<p>Creates a global table from an existing table. A global table creates a replication relationship between two or more DynamoDB tables with the same table name in the provided regions. </p> <p>If you want to add a new replica table to a global table, each of the following conditions must be true:</p> <ul> <li> <p>The table must have the same primary key as all of the other replicas.</p> </li> <li> <p>The table must have the same name as all of the other replicas.</p> </li> <li> <p>The table must have DynamoDB Streams enabled, with the stream containing both the new and the old images of the item.</p> </li> <li> <p>None of the replica tables in the global table can contain any data.</p> </li> </ul> <p> If global secondary indexes are specified, then the following conditions must also be met: </p> <ul> <li> <p> The global secondary indexes must have the same name. </p> </li> <li> <p> The global secondary indexes must have the same hash key and sort key (if present). </p> </li> </ul> <important> <p> Write capacity settings should be set consistently across your replica tables and secondary indexes. DynamoDB strongly recommends enabling auto scaling to manage the write capacity settings for all of your global tables replicas and indexes. </p> <p> If you prefer to manage write capacity settings manually, you should provision equal replicated write capacity units to your replica tables. You should also provision equal replicated write capacity units to matching secondary indexes across your global table. </p> </important>",
|
||||
"CreateTable": "<p>The <code>CreateTable</code> operation adds a new table to your account. In an AWS account, table names must be unique within each region. That is, you can have two tables with same name if you create the tables in different regions.</p> <p> <code>CreateTable</code> is an asynchronous operation. Upon receiving a <code>CreateTable</code> request, DynamoDB immediately returns a response with a <code>TableStatus</code> of <code>CREATING</code>. After the table is created, DynamoDB sets the <code>TableStatus</code> to <code>ACTIVE</code>. You can perform read and write operations only on an <code>ACTIVE</code> table. </p> <p>You can optionally define secondary indexes on the new table, as part of the <code>CreateTable</code> operation. If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially. Only one table with secondary indexes can be in the <code>CREATING</code> state at any given time.</p> <p>You can use the <code>DescribeTable</code> action to check the table status.</p>",
|
||||
"DeleteBackup": "<p>Deletes an existing backup of a table.</p> <p>You can call <code>DeleteBackup</code> at a maximum rate of 10 times per second.</p>",
|
||||
"DeleteItem": "<p>Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value.</p> <p>In addition to deleting an item, you can also return the item's attribute values in the same operation, using the <code>ReturnValues</code> parameter.</p> <p>Unless you specify conditions, the <code>DeleteItem</code> is an idempotent operation; running it multiple times on the same item or attribute does <i>not</i> result in an error response.</p> <p>Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.</p>",
|
||||
|
|
@ -139,8 +139,8 @@
|
|||
"BackupSummary$BackupArn": "<p>ARN associated with the backup.</p>",
|
||||
"DeleteBackupInput$BackupArn": "<p>The ARN associated with the backup.</p>",
|
||||
"DescribeBackupInput$BackupArn": "<p>The ARN associated with the backup.</p>",
|
||||
"ListBackupsInput$ExclusiveStartBackupArn": "<p> <code>LastEvaluatedBackupARN</code> returned by the previous ListBackups call. </p>",
|
||||
"ListBackupsOutput$LastEvaluatedBackupArn": "<p>Last evaluated BackupARN.</p>",
|
||||
"ListBackupsInput$ExclusiveStartBackupArn": "<p> <code>LastEvaluatedBackupArn</code> is the ARN of the backup last evaluated when the current page of results was returned, inclusive of the current page of results. This value may be specified as the <code>ExclusiveStartBackupArn</code> of a new <code>ListBackups</code> operation in order to fetch the next page of results. </p>",
|
||||
"ListBackupsOutput$LastEvaluatedBackupArn": "<p> The ARN of the backup last evaluated when the current page of results was returned, inclusive of the current page of results. This value may be specified as the <code>ExclusiveStartBackupArn</code> of a new <code>ListBackups</code> operation in order to fetch the next page of results. </p> <p> If <code>LastEvaluatedBackupArn</code> is empty, then the last page of results has been processed and there are no more results to be retrieved. </p> <p> If <code>LastEvaluatedBackupArn</code> is not empty, this may or may not indicate there is more data to be returned. All results are guaranteed to have been returned if and only if no value for <code>LastEvaluatedBackupArn</code> is returned. </p>",
|
||||
"RestoreSummary$SourceBackupArn": "<p>ARN of the backup from which the table was restored.</p>",
|
||||
"RestoreTableFromBackupInput$BackupArn": "<p>The ARN associated with the backup.</p>"
|
||||
}
|
||||
|
|
@ -368,7 +368,7 @@
|
|||
"ContinuousBackupsDescription": {
|
||||
"base": "<p>Represents the continuous backups and point in time recovery settings on the table.</p>",
|
||||
"refs": {
|
||||
"DescribeContinuousBackupsOutput$ContinuousBackupsDescription": "<p> <code>ContinuousBackupsDescription</code> can be one of the following : ENABLED, DISABLED. </p>",
|
||||
"DescribeContinuousBackupsOutput$ContinuousBackupsDescription": "<p>Represents the continuous backups and point in time recovery settings on the table.</p>",
|
||||
"UpdateContinuousBackupsOutput$ContinuousBackupsDescription": "<p>Represents the continuous backups and point in time recovery settings on the table.</p>"
|
||||
}
|
||||
},
|
||||
|
|
@ -857,6 +857,12 @@
|
|||
"ScanOutput$Items": "<p>An array of item attributes that match the scan criteria. Each element in this array consists of an attribute name and the value for that attribute.</p>"
|
||||
}
|
||||
},
|
||||
"KMSMasterKeyArn": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"SSEDescription$KMSMasterKeyArn": "<p>The KMS master key ARN used for the KMS encryption.</p>"
|
||||
}
|
||||
},
|
||||
"Key": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
|
|
@ -930,7 +936,7 @@
|
|||
}
|
||||
},
|
||||
"LimitExceededException": {
|
||||
"base": "<p>Up to 50 <code>CreateBackup</code> operations are allowed per second, per account. There is no limit to the number of daily on-demand backups that can be taken. </p> <p>Up to 10 simultaneous table operations are allowed per account. These operations include <code>CreateTable</code>, <code>UpdateTable</code>, <code>DeleteTable</code>,<code>UpdateTimeToLive</code>, <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>. </p> <p>For tables with secondary indexes, only one of those tables can be in the <code>CREATING</code> state at any point in time. Do not attempt to create more than one such table simultaneously.</p> <p>The total limit of tables in the <code>ACTIVE</code> state is 250.</p>",
|
||||
"base": "<p>There is no limit to the number of daily on-demand backups that can be taken. </p> <p>Up to 10 simultaneous table operations are allowed per account. These operations include <code>CreateTable</code>, <code>UpdateTable</code>, <code>DeleteTable</code>,<code>UpdateTimeToLive</code>, <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>. </p> <p>For tables with secondary indexes, only one of those tables can be in the <code>CREATING</code> state at any point in time. Do not attempt to create more than one such table simultaneously.</p> <p>The total limit of tables in the <code>ACTIVE</code> state is 250.</p>",
|
||||
"refs": {
|
||||
}
|
||||
},
|
||||
|
|
@ -1434,6 +1440,12 @@
|
|||
"SSEDescription$Status": "<p>The current state of server-side encryption:</p> <ul> <li> <p> <code>ENABLING</code> - Server-side encryption is being enabled.</p> </li> <li> <p> <code>ENABLED</code> - Server-side encryption is enabled.</p> </li> <li> <p> <code>DISABLING</code> - Server-side encryption is being disabled.</p> </li> <li> <p> <code>DISABLED</code> - Server-side encryption is disabled.</p> </li> </ul>"
|
||||
}
|
||||
},
|
||||
"SSEType": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
"SSEDescription$SSEType": "<p>Server-side encryption type:</p> <ul> <li> <p> <code>AES256</code> - Server-side encryption which uses the AES256 algorithm.</p> </li> <li> <p> <code>KMS</code> - Server-side encryption which uses AWS Key Management Service.</p> </li> </ul>"
|
||||
}
|
||||
},
|
||||
"ScalarAttributeType": {
|
||||
"base": null,
|
||||
"refs": {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue