ddb

type Attribute struct {
	FieldName     string
	AttributeName string
	Tags          map[string]string
	Type          types.ScalarAttributeType
}

type Attributes map[string]*Attribute

type BatchGetItemsBuilder interface {
	WithKeys(values ...interface{}) BatchGetItemsBuilder
	WithKeyPairs(pairs [][]interface{}) BatchGetItemsBuilder
	WithHashKeys(hashKeys interface{}) BatchGetItemsBuilder
	DisableTtlFilter() BatchGetItemsBuilder
	WithProjection(projection interface{}) BatchGetItemsBuilder
	WithConsistentRead(consistentRead bool) BatchGetItemsBuilder
	Build(result interface{}) (*dynamodb.BatchGetItemInput, error)
}

type Capacity struct {
	// contains filtered or unexported fields
}

type ConditionCheckBuilder interface {
	Build(result interface{}) (*types.ConditionCheck, error)
	ReturnNone() ConditionCheckBuilder
	ReturnAllOld() ConditionCheckBuilder
	WithHash(hashValue interface{}) ConditionCheckBuilder
	WithRange(rangeValue interface{}) ConditionCheckBuilder
	WithKeys(keys ...interface{}) ConditionCheckBuilder
	WithCondition(cond expression.ConditionBuilder) ConditionCheckBuilder
}

type ConsumedCapacity struct {
	Capacity
	Table Capacity
	LSI   map[string]*Capacity
	GSI   map[string]*Capacity
}

type DdbWriterOption func(settings *Settings)

type DeleteItemBuilder interface {
	WithHash(hashValue interface{}) DeleteItemBuilder
	WithRange(rangeValue interface{}) DeleteItemBuilder
	WithCondition(cond expression.ConditionBuilder) DeleteItemBuilder
	ReturnNone() DeleteItemBuilder
	ReturnAllOld() DeleteItemBuilder
	Build(item interface{}) (*dynamodb.DeleteItemInput, error)
}

type DeleteItemResult struct {
	ConditionalCheckFailed bool
	ConsumedCapacity       *ConsumedCapacity
}

type FieldAware interface {
	KeyAware
	GetModel() interface{}
	ContainsField(field string) bool
	GetFields() []string
}

type GetItemBuilder interface {
	WithHash(hashValue interface{}) GetItemBuilder
	WithRange(rangeValue interface{}) GetItemBuilder
	WithKeys(keys ...interface{}) GetItemBuilder
	DisableTtlFilter() GetItemBuilder
	WithProjection(rangeValue interface{}) GetItemBuilder
	WithConsistentRead(consistentRead bool) GetItemBuilder
	Build(result interface{}) (*dynamodb.GetItemInput, error)
}

type GetItemResult struct {
	IsFound          bool
	ConsumedCapacity *ConsumedCapacity
}

type GlobalSettings struct {
	Name               string
	Model              any
	ReadCapacityUnits  int64
	WriteCapacityUnits int64
}

type KeyAware interface {
	IsKeyField(field string) bool
	GetHashKey() *string
	GetRangeKey() *string
	GetKeyFields() []string
}

type KeyValues map[string]types.AttributeValue

type LifeCyclePurger struct {
	// contains filtered or unexported fields
}

type LifecycleManager interface {
	reslife.LifeCycleer
	reslife.Creator
	reslife.Registerer
	reslife.Purger
}

type LocalSettings struct {
	Name  string
	Model any
}

type MainSettings struct {
	Model              any
	StreamView         types.StreamViewType
	ReadCapacityUnits  int64
	WriteCapacityUnits int64
}

type Metadata struct {
	TableName  string
	Attributes Attributes
	TimeToLive metadataTtl
	Main       metadataMain
	Local      metaLocal
	Global     metaGlobal
}

type MetadataFactory struct {
	// contains filtered or unexported fields
}

type OperationResult struct {
	ConsumedCapacity *ConsumedCapacity
}

type Progress interface {
	GetRequestCount() int32
	GetItemCount() int32
	GetScannedCount() int32
	GetConsumedCapacity() *ConsumedCapacity
}

type PutItemBuilder interface {
	WithCondition(cond expression.ConditionBuilder) PutItemBuilder
	ReturnNone() PutItemBuilder
	ReturnAllOld() PutItemBuilder
	Build(item interface{}) (*dynamodb.PutItemInput, error)
}

type PutItemResult struct {
	ConditionalCheckFailed bool
	ConsumedCapacity       *ConsumedCapacity
	IsReturnEmpty          bool
}

type QueryBuilder interface {
	WithIndex(name string) QueryBuilder
	WithHash(value interface{}) QueryBuilder
	WithRangeBetween(lower interface{}, upper interface{}) QueryBuilder
	WithRangeBeginsWith(prefix string) QueryBuilder
	WithRangeEq(value interface{}) QueryBuilder
	WithRangeGt(value interface{}) QueryBuilder
	WithRangeGte(value interface{}) QueryBuilder
	WithRangeLt(value interface{}) QueryBuilder
	WithRangeLte(value interface{}) QueryBuilder
	WithFilter(filter expression.ConditionBuilder) QueryBuilder
	DisableTtlFilter() QueryBuilder
	WithProjection(projection interface{}) QueryBuilder
	WithLimit(limit int) QueryBuilder
	WithPageSize(size int) QueryBuilder
	WithDescendingOrder() QueryBuilder
	WithConsistentRead(consistentRead bool) QueryBuilder
	Build(result interface{}) (*QueryOperation, error)
}

type QueryOperation struct {
	// contains filtered or unexported fields
}

type QueryResult struct {
	RequestCount     int32
	ItemCount        int32
	ScannedCount     int32
	ConsumedCapacity *ConsumedCapacity
}

type Repository interface {
	GetModelId() mdl.ModelId

	BatchDeleteItems(ctx context.Context, value any) (*OperationResult, error)
	BatchGetItems(ctx context.Context, qb BatchGetItemsBuilder, result any) (*OperationResult, error)
	BatchPutItems(ctx context.Context, items any) (*OperationResult, error)
	DeleteItem(ctx context.Context, db DeleteItemBuilder, item any) (*DeleteItemResult, error)
	GetItem(ctx context.Context, qb GetItemBuilder, result any) (*GetItemResult, error)
	PutItem(ctx context.Context, qb PutItemBuilder, item any) (*PutItemResult, error)
	Query(ctx context.Context, qb QueryBuilder, result any) (*QueryResult, error)
	Scan(ctx context.Context, sb ScanBuilder, result any) (*ScanResult, error)
	UpdateItem(ctx context.Context, ub UpdateItemBuilder, item any) (*UpdateItemResult, error)

	BatchGetItemsBuilder() BatchGetItemsBuilder
	DeleteItemBuilder() DeleteItemBuilder
	GetItemBuilder() GetItemBuilder
	QueryBuilder() QueryBuilder
	PutItemBuilder() PutItemBuilder
	ScanBuilder() ScanBuilder
	UpdateItemBuilder() UpdateItemBuilder
}

type ResultCallback func(ctx context.Context, items interface{}, progress Progress) (bool, error)

type ScanBuilder interface {
	WithIndex(name string) ScanBuilder
	WithFilter(filter expression.ConditionBuilder) ScanBuilder
	DisableTtlFilter() ScanBuilder
	WithProjection(projection interface{}) ScanBuilder
	WithLimit(limit int) ScanBuilder
	WithPageSize(size int) ScanBuilder
	WithSegment(segment int, total int) ScanBuilder
	WithConsistentRead(consistentRead bool) ScanBuilder
	Build(result interface{}) (*ScanOperation, error)
}

type ScanOperation struct {
	// contains filtered or unexported fields
}

type ScanResult struct {
	RequestCount     int32
	ItemCount        int32
	ScannedCount     int32
	ConsumedCapacity *ConsumedCapacity
}

type Service struct {
	// contains filtered or unexported fields
}

type Settings struct {
	ModelId             mdl.ModelId
	TableNamingSettings TableNamingSettings
	DisableTracing      bool
	ClientName          string
	Main                MainSettings
	Local               []LocalSettings
	Global              []GlobalSettings
}

type SimpleSettings struct {
	ModelId            mdl.ModelId
	AutoCreate         bool
	Model              any
	StreamView         string
	ReadCapacityUnits  int64
	WriteCapacityUnits int64
}

type TableDescription struct {
	Name      string
	ItemCount int64
}

type TableMetadata struct {
	AwsClientName string `json:"aws_client_name"`
	TableName     string `json:"table_name"`
}

type TableNamingSettings struct {
	Pattern string `cfg:"pattern,nodecode" default:"{project}-{env}-{family}-{group}-{modelId}"`
}

type TableNotFoundError struct {
	TableName string
	// contains filtered or unexported fields
}

type TransactConditionCheck struct {
	Builder ConditionCheckBuilder
	Item    interface{}
}

type TransactDeleteItem struct {
	Builder DeleteItemBuilder
	Item    interface{}
}

type TransactGetItem struct {
	Builder GetItemBuilder
	Item    interface{}
}

type TransactGetItemBuilder interface {
	Build() (types.TransactGetItem, error)
	GetItem() interface{}
}

type TransactPutItem struct {
	Builder PutItemBuilder
	Item    interface{}
}

type TransactUpdateItem struct {
	Builder UpdateItemBuilder
	Item    interface{}
}

type TransactWriteItemBuilder interface {
	Build() (*types.TransactWriteItem, error)
	GetItem() interface{}
}

type TransactionRepository interface {
	TransactWriteItems(ctx context.Context, items []TransactWriteItemBuilder) (*OperationResult, error)
	TransactGetItems(ctx context.Context, items []TransactGetItemBuilder) (*OperationResult, error)
}

type Unmarshaller struct {
	// contains filtered or unexported fields
}

type UpdateItemBuilder interface {
	WithHash(hashValue interface{}) UpdateItemBuilder
	WithRange(rangeValue interface{}) UpdateItemBuilder
	WithCondition(cond expression.ConditionBuilder) UpdateItemBuilder
	Add(path string, value interface{}) UpdateItemBuilder
	Delete(path string, value interface{}) UpdateItemBuilder
	Set(path string, value interface{}) UpdateItemBuilder
	SetMap(values map[string]interface{}) UpdateItemBuilder
	SetIfNotExist(path string, value interface{}) UpdateItemBuilder
	Remove(path string) UpdateItemBuilder
	RemoveMultiple(paths ...string) UpdateItemBuilder
	ReturnNone() UpdateItemBuilder
	ReturnAllOld() UpdateItemBuilder
	ReturnUpdatedOld() UpdateItemBuilder
	ReturnAllNew() UpdateItemBuilder
	ReturnUpdatedNew() UpdateItemBuilder
	Build(item interface{}) (*dynamodb.UpdateItemInput, error)
}

type UpdateItemResult struct {
	ConditionalCheckFailed bool
	ConsumedCapacity       *ConsumedCapacity
}