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 ...any) BatchGetItemsBuilder
	WithKeyPairs(pairs [][]any) BatchGetItemsBuilder
	WithHashKeys(hashKeys any) BatchGetItemsBuilder
	DisableTtlFilter() BatchGetItemsBuilder
	WithProjection(projection any) BatchGetItemsBuilder
	WithConsistentRead(consistentRead bool) BatchGetItemsBuilder
	Build(result any) (*dynamodb.BatchGetItemInput, error)
}

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

type ConditionCheckBuilder interface {
	Build(result any) (*types.ConditionCheck, error)
	ReturnNone() ConditionCheckBuilder
	ReturnAllOld() ConditionCheckBuilder
	WithHash(hashValue any) ConditionCheckBuilder
	WithRange(rangeValue any) ConditionCheckBuilder
	WithKeys(keys ...any) 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 any) DeleteItemBuilder
	WithRange(rangeValue any) DeleteItemBuilder
	WithCondition(cond expression.ConditionBuilder) DeleteItemBuilder
	ReturnNone() DeleteItemBuilder
	ReturnAllOld() DeleteItemBuilder
	Build(item any) (*dynamodb.DeleteItemInput, error)
}

type DeleteItemResult struct {
	ConditionalCheckFailed bool
	ConsumedCapacity       *ConsumedCapacity
}

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

type GetItemBuilder interface {
	WithHash(hashValue any) GetItemBuilder
	WithRange(rangeValue any) GetItemBuilder
	WithKeys(keys ...any) GetItemBuilder
	DisableTtlFilter() GetItemBuilder
	WithProjection(rangeValue any) GetItemBuilder
	WithConsistentRead(consistentRead bool) GetItemBuilder
	Build(result any) (*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 any) (*dynamodb.PutItemInput, error)
}

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

type QueryBuilder interface {
	WithIndex(name string) QueryBuilder
	WithHash(value any) QueryBuilder
	WithRangeBetween(lower any, upper any) QueryBuilder
	WithRangeBeginsWith(prefix string) QueryBuilder
	WithRangeEq(value any) QueryBuilder
	WithRangeGt(value any) QueryBuilder
	WithRangeGte(value any) QueryBuilder
	WithRangeLt(value any) QueryBuilder
	WithRangeLte(value any) QueryBuilder
	WithFilter(filter expression.ConditionBuilder) QueryBuilder
	DisableTtlFilter() QueryBuilder
	WithProjection(projection any) QueryBuilder
	WithLimit(limit int) QueryBuilder
	WithPageSize(size int) QueryBuilder
	WithDescendingOrder() QueryBuilder
	WithConsistentRead(consistentRead bool) QueryBuilder
	Build(result any) (*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 any, progress Progress) (bool, error)

type ScanBuilder interface {
	WithIndex(name string) ScanBuilder
	WithFilter(filter expression.ConditionBuilder) ScanBuilder
	DisableTtlFilter() ScanBuilder
	WithProjection(projection any) ScanBuilder
	WithLimit(limit int) ScanBuilder
	WithPageSize(size int) ScanBuilder
	WithSegment(segment int, total int) ScanBuilder
	WithConsistentRead(consistentRead bool) ScanBuilder
	Build(result any) (*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    any
}

type TransactDeleteItem struct {
	Builder DeleteItemBuilder
	Item    any
}

type TransactGetItem struct {
	Builder GetItemBuilder
	Item    any
}

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

type TransactPutItem struct {
	Builder PutItemBuilder
	Item    any
}

type TransactUpdateItem struct {
	Builder UpdateItemBuilder
	Item    any
}

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

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 any) UpdateItemBuilder
	WithRange(rangeValue any) UpdateItemBuilder
	WithCondition(cond expression.ConditionBuilder) UpdateItemBuilder
	Add(path string, value any) UpdateItemBuilder
	Delete(path string, value any) UpdateItemBuilder
	Set(path string, value any) UpdateItemBuilder
	SetMap(values map[string]any) UpdateItemBuilder
	SetIfNotExist(path string, value any) UpdateItemBuilder
	Remove(path string) UpdateItemBuilder
	RemoveMultiple(paths ...string) UpdateItemBuilder
	ReturnNone() UpdateItemBuilder
	ReturnAllOld() UpdateItemBuilder
	ReturnUpdatedOld() UpdateItemBuilder
	ReturnAllNew() UpdateItemBuilder
	ReturnUpdatedNew() UpdateItemBuilder
	Build(item any) (*dynamodb.UpdateItemInput, error)
}

type UpdateItemResult struct {
	ConditionalCheckFailed bool
	ConsumedCapacity       *ConsumedCapacity
}