v0.5.0: manifests, filters, logging, docs

internal/photos/bridge.go

@@ -10,9 +10,9 @@ type Bridge interface {
 	ListAlbums() ([]Album, error)
 	ListAssets(albumID string) ([]Asset, int, error)
 	ListTree() ([]CollectionNode, error)
-	ExportPreview(assetID, outputDir string, targetSize, index int) (ExportResult, error)
+	ExportPreview(assetID, outputDir string, targetSize, quality, index int) (ExportResult, error)
 	ExportOriginal(assetID, outputDir string, index int) (ExportResult, error)
-	ExportPreviewWithSlot(assetID, outputDir string, targetSize, index, slotIndex int) (ExportResult, error)
+	ExportPreviewWithSlot(assetID, outputDir string, targetSize, quality, index, slotIndex int) (ExportResult, error)
 	ExportOriginalWithSlot(assetID, outputDir string, index, slotIndex int) (ExportResult, error)
 	Cancel()
 	IsCancelled() bool

internal/photos/cgo_bridge.go

@@ -62,29 +62,29 @@ func (*CgoBridge) IsCancelled() bool {
 	return C.photos_request_is_cancelled() != 0
 }
 
-func (*CgoBridge) ExportPreview(assetID, outputDir string, targetSize, index int) (ExportResult, error) {
-	return exportPreviewWithSlot(assetID, outputDir, targetSize, index, -1)
+func (*CgoBridge) ExportPreview(assetID, outputDir string, targetSize, quality, index int) (ExportResult, error) {
+	return exportPreviewWithSlot(assetID, outputDir, targetSize, quality, index, -1)
 }
 
 func (*CgoBridge) ExportOriginal(assetID, outputDir string, index int) (ExportResult, error) {
 	return exportOriginalWithSlot(assetID, outputDir, index, -1)
 }
 
-func (*CgoBridge) ExportPreviewWithSlot(assetID, outputDir string, targetSize, index, slotIndex int) (ExportResult, error) {
-	return exportPreviewWithSlot(assetID, outputDir, targetSize, index, slotIndex)
+func (*CgoBridge) ExportPreviewWithSlot(assetID, outputDir string, targetSize, quality, index, slotIndex int) (ExportResult, error) {
+	return exportPreviewWithSlot(assetID, outputDir, targetSize, quality, index, slotIndex)
 }
 
 func (*CgoBridge) ExportOriginalWithSlot(assetID, outputDir string, index, slotIndex int) (ExportResult, error) {
 	return exportOriginalWithSlot(assetID, outputDir, index, slotIndex)
 }
 
-func exportPreviewWithSlot(assetID, outputDir string, targetSize, index, slotIndex int) (ExportResult, error) {
+func exportPreviewWithSlot(assetID, outputDir string, targetSize, quality, index, slotIndex int) (ExportResult, error) {
 	cid := C.CString(assetID)
 	defer C.free(unsafe.Pointer(cid))
 	cdir := C.CString(outputDir)
 	defer C.free(unsafe.Pointer(cdir))
 
-	cs := C.photos_export_preview_json(cid, cdir, C.int(targetSize), C.int(index), C.int(slotIndex))
+	cs := C.photos_export_preview_json(cid, cdir, C.int(targetSize), C.int(quality), C.int(index), C.int(slotIndex))
 	if cs == nil {
 		return ExportResult{}, errBridgeNil
 	}
@@ -117,8 +117,8 @@ func GetProgressSlots() []ExportProgressSlot {
 		ptr := (*C.export_progress_t)(unsafe.Pointer(uintptr(unsafe.Pointer(slots)) + uintptr(i)*unsafe.Sizeof(C.export_progress_t{})))
 		result[i] = ExportProgressSlot{
 			Active:     ptr.active != 0,
-			Progress:  float64(ptr.progress),
-			BytesDone: int64(ptr.bytes_done),
+			Progress:   float64(ptr.progress),
+			BytesDone:  int64(ptr.bytes_done),
 			BytesTotal: int64(ptr.bytes_total),
 		}
 	}
@@ -129,6 +129,10 @@ func ResetProgressSlots() {
 	C.photos_reset_progress_slots()
 }
 
+func GetProgressSlotCount() int {
+	return int(C.photos_get_progress_slot_count())
+}
+
 type ExportProgressSlot struct {
 	Active     bool
 	Progress   float64

internal/photos/cgo_bridge_test_impl.go

@@ -17,7 +17,11 @@ void photos_test_set_assets_null(void);
 void photos_test_set_tree_null(void);
 void photos_request_cancel(void);
 void photos_test_set_export_preview_json(const char *json);
+void photos_test_set_export_preview_json_null(void);
 void photos_test_set_export_original_json(const char *json);
+void photos_test_set_export_original_json_null(void);
+void photos_test_set_progress_slot_count(int count);
+void photos_test_set_progress_slots_null(int val);
 */
 import "C"
 
@@ -27,15 +31,19 @@ type CgoBridge struct{}
 
 var DefaultBridge Bridge = &CgoBridge{}
 
-func SetTestAccessRC(rc int)          { C.photos_test_set_access(C.int(rc)) }
-func SetTestAlbumsJSON(json string)   { C.photos_test_set_albums(C.CString(json)) }
-func SetTestAssetsJSON(json string)   { C.photos_test_set_assets(C.CString(json)) }
-func SetTestTreeJSON(json string)     { C.photos_test_set_tree(C.CString(json)) }
-func SetTestAlbumsNull()              { C.photos_test_set_albums_null() }
-func SetTestAssetsNull()              { C.photos_test_set_assets_null() }
-func SetTestTreeNull()                { C.photos_test_set_tree_null() }
-func SetTestExportPreviewJSON(json string) { C.photos_test_set_export_preview_json(C.CString(json)) }
+func SetTestAccessRC(rc int)                { C.photos_test_set_access(C.int(rc)) }
+func SetTestAlbumsJSON(json string)         { C.photos_test_set_albums(C.CString(json)) }
+func SetTestAssetsJSON(json string)         { C.photos_test_set_assets(C.CString(json)) }
+func SetTestTreeJSON(json string)           { C.photos_test_set_tree(C.CString(json)) }
+func SetTestAlbumsNull()                    { C.photos_test_set_albums_null() }
+func SetTestAssetsNull()                    { C.photos_test_set_assets_null() }
+func SetTestTreeNull()                      { C.photos_test_set_tree_null() }
+func SetTestExportPreviewJSON(json string)  { C.photos_test_set_export_preview_json(C.CString(json)) }
+func SetTestExportPreviewJSONNull()         { C.photos_test_set_export_preview_json_null() }
 func SetTestExportOriginalJSON(json string) { C.photos_test_set_export_original_json(C.CString(json)) }
+func SetTestExportOriginalJSONNull()        { C.photos_test_set_export_original_json_null() }
+func SetTestProgressSlotCount(count int)    { C.photos_test_set_progress_slot_count(C.int(count)) }
+func SetTestProgressSlotsNull(val int)      { C.photos_test_set_progress_slots_null(C.int(val)) }
 
 func (*CgoBridge) RequestAccess() error {
 	rc := C.photos_request_access()
@@ -82,28 +90,28 @@ func (*CgoBridge) IsCancelled() bool {
 	return C.photos_request_is_cancelled() != 0
 }
 
-func (*CgoBridge) ExportPreview(assetID, outputDir string, targetSize, index int) (ExportResult, error) {
-	return exportPreviewWithSlotTest(assetID, outputDir, targetSize, index, -1)
+func (*CgoBridge) ExportPreview(assetID, outputDir string, targetSize, quality, index int) (ExportResult, error) {
+	return exportPreviewWithSlotTest(assetID, outputDir, targetSize, quality, index, -1)
 }
 
 func (*CgoBridge) ExportOriginal(assetID, outputDir string, index int) (ExportResult, error) {
 	return exportOriginalWithSlotTest(assetID, outputDir, index, -1)
 }
 
-func (*CgoBridge) ExportPreviewWithSlot(assetID, outputDir string, targetSize, index, slotIndex int) (ExportResult, error) {
-	return exportPreviewWithSlotTest(assetID, outputDir, targetSize, index, slotIndex)
+func (*CgoBridge) ExportPreviewWithSlot(assetID, outputDir string, targetSize, quality, index, slotIndex int) (ExportResult, error) {
+	return exportPreviewWithSlotTest(assetID, outputDir, targetSize, quality, index, slotIndex)
 }
 
 func (*CgoBridge) ExportOriginalWithSlot(assetID, outputDir string, index, slotIndex int) (ExportResult, error) {
 	return exportOriginalWithSlotTest(assetID, outputDir, index, slotIndex)
 }
 
-func exportPreviewWithSlotTest(assetID, outputDir string, targetSize, index, slotIndex int) (ExportResult, error) {
+func exportPreviewWithSlotTest(assetID, outputDir string, targetSize, quality, index, slotIndex int) (ExportResult, error) {
 	cid := C.CString(assetID)
 	defer C.free(unsafe.Pointer(cid))
 	cdir := C.CString(outputDir)
 	defer C.free(unsafe.Pointer(cdir))
-	cs := C.photos_export_preview_json(cid, cdir, C.int(targetSize), C.int(index), C.int(slotIndex))
+	cs := C.photos_export_preview_json(cid, cdir, C.int(targetSize), C.int(quality), C.int(index), C.int(slotIndex))
 	if cs == nil {
 		return ExportResult{}, errBridgeNil
 	}
@@ -132,8 +140,31 @@ type ExportProgressSlot struct {
 }
 
 func GetProgressSlots() []ExportProgressSlot {
-	return nil
+	count := int(C.photos_get_progress_slot_count())
+	if count <= 0 {
+		return nil
+	}
+	cSlots := C.photos_get_progress_slots()
+	if cSlots == nil {
+		return nil
+	}
+	slots := make([]ExportProgressSlot, count)
+	for i := 0; i < count; i++ {
+		s := C.photos_get_progress_slot(cSlots, C.int(i))
+		slots[i] = ExportProgressSlot{
+			Active:     s.active != 0,
+			Progress:   float64(s.progress),
+			BytesDone:  int64(s.bytes_done),
+			BytesTotal: int64(s.bytes_total),
+		}
+	}
+	return slots
 }
 
 func ResetProgressSlots() {
+	C.photos_reset_progress_slots()
+}
+
+func GetProgressSlotCount() int {
+	return int(C.photos_get_progress_slot_count())
 }

internal/photos/photos.go

@@ -5,4 +5,4 @@ package photos
 import "fmt"
 
 var errAccessDenied = fmt.Errorf("photos access denied: grant Full Disk Access or Photos permission in System Settings > Privacy & Security")
-var errBridgeNil = fmt.Errorf("bridge returned nil")
+var errBridgeNil = fmt.Errorf("bridge returned nil")

internal/photos/photos_test.go

@@ -35,9 +35,9 @@ func TestParseAlbumsJSON(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name:    "missing albums key",
-			json:    `{}`,
-			want:    []Album{},
+			name: "missing albums key",
+			json: `{}`,
+			want: []Album{},
 		},
 	}
 
@@ -66,23 +66,23 @@ func TestParseAlbumsJSON(t *testing.T) {
 
 func TestParseAssetsJSON(t *testing.T) {
 	tests := []struct {
-		name     string
-		json     string
-		want     []Asset
+		name      string
+		json      string
+		want      []Asset
 		wantTotal int
-		wantErr  bool
-		errMsg   string
+		wantErr   bool
+		errMsg    string
 	}{
 		{
-			name: "empty assets",
-			json: `{"assets":[],"total":0}`,
-			want: []Asset{},
+			name:      "empty assets",
+			json:      `{"assets":[],"total":0}`,
+			want:      []Asset{},
 			wantTotal: 0,
 		},
 		{
-			name: "single asset",
-			json: `{"assets":[{"id":"asset1","filename":"IMG_0001.JPG"}],"total":1}`,
-			want: []Asset{{ID: "asset1", Filename: "IMG_0001.JPG"}},
+			name:      "single asset",
+			json:      `{"assets":[{"id":"asset1","filename":"IMG_0001.JPG"}],"total":1}`,
+			want:      []Asset{{ID: "asset1", Filename: "IMG_0001.JPG"}},
 			wantTotal: 1,
 		},
 		{
@@ -106,9 +106,9 @@ func TestParseAssetsJSON(t *testing.T) {
 			wantTotal: 1,
 		},
 		{
-			name: "multiple assets",
-			json: `{"assets":[{"id":"a1","filename":"a.jpg"},{"id":"a2","filename":"b.jpg"},{"id":"a3","filename":"c.jpg"}],"total":3}`,
-			want: []Asset{{ID: "a1", Filename: "a.jpg"}, {ID: "a2", Filename: "b.jpg"}, {ID: "a3", Filename: "c.jpg"}},
+			name:      "multiple assets",
+			json:      `{"assets":[{"id":"a1","filename":"a.jpg"},{"id":"a2","filename":"b.jpg"},{"id":"a3","filename":"c.jpg"}],"total":3}`,
+			want:      []Asset{{ID: "a1", Filename: "a.jpg"}, {ID: "a2", Filename: "b.jpg"}, {ID: "a3", Filename: "c.jpg"}},
 			wantTotal: 3,
 		},
 		{
@@ -132,9 +132,9 @@ func TestParseAssetsJSON(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name: "empty error is not an error",
-			json: `{"error":"","assets":[{"id":"a1","filename":"IMG.JPG"}],"total":1}`,
-			want: []Asset{{ID: "a1", Filename: "IMG.JPG"}},
+			name:      "empty error is not an error",
+			json:      `{"error":"","assets":[{"id":"a1","filename":"IMG.JPG"}],"total":1}`,
+			want:      []Asset{{ID: "a1", Filename: "IMG.JPG"}},
 			wantTotal: 1,
 		},
 	}
@@ -407,11 +407,11 @@ func TestErrBridgeNilMessage(t *testing.T) {
 
 func TestParseExportResultJSON(t *testing.T) {
 	tests := []struct {
-		name       string
-		json       string
-		want       ExportResult
-		wantErr    bool
-		errMsg     string
+		name    string
+		json    string
+		want    ExportResult
+		wantErr bool
+		errMsg  string
 	}{
 		{
 			name: "success",
@@ -488,3 +488,244 @@ func equalAsset(a, b Asset) bool {
 	}
 	return true
 }
+
+func TestCgoBridgeExportPreviewViaStub(t *testing.T) {
+	SetTestExportPreviewJSON(`{"filename":"0001_img.jpg","size":2048,"cloud":"local"}`)
+	defer SetTestExportPreviewJSON(`{"filename":"0000_test.jpg","size":1024,"cloud":"local"}`)
+	bridge := &CgoBridge{}
+	result, err := bridge.ExportPreview("asset-1", "/tmp", 1024, 85, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Filename != "0001_img.jpg" {
+		t.Errorf("got filename %q, want %q", result.Filename, "0001_img.jpg")
+	}
+	if result.Size != 2048 {
+		t.Errorf("got size %d, want %d", result.Size, 2048)
+	}
+	if result.Cloud != "local" {
+		t.Errorf("got cloud %q, want %q", result.Cloud, "local")
+	}
+}
+
+func TestCgoBridgeExportPreviewWithSlotViaStub(t *testing.T) {
+	SetTestExportPreviewJSON(`{"filename":"slot_img.jpg","size":4096,"cloud":"cloud"}`)
+	defer SetTestExportPreviewJSON(`{"filename":"0000_test.jpg","size":1024,"cloud":"local"}`)
+	bridge := &CgoBridge{}
+	result, err := bridge.ExportPreviewWithSlot("asset-1", "/tmp", 2048, 85, 0, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Filename != "slot_img.jpg" {
+		t.Errorf("got filename %q", result.Filename)
+	}
+	if result.Cloud != "cloud" {
+		t.Errorf("got cloud %q, want %q", result.Cloud, "cloud")
+	}
+}
+
+func TestCgoBridgeExportOriginalViaStub(t *testing.T) {
+	SetTestExportOriginalJSON(`{"filename":"original.jpg","size":8192,"cloud":"local"}`)
+	defer SetTestExportOriginalJSON(`{"filename":"test.jpg","size":2048,"cloud":"cloud"}`)
+	bridge := &CgoBridge{}
+	result, err := bridge.ExportOriginal("asset-1", "/tmp", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Filename != "original.jpg" {
+		t.Errorf("got filename %q, want %q", result.Filename, "original.jpg")
+	}
+	if result.Size != 8192 {
+		t.Errorf("got size %d, want %d", result.Size, 8192)
+	}
+}
+
+func TestCgoBridgeExportOriginalWithSlotViaStub(t *testing.T) {
+	SetTestExportOriginalJSON(`{"filename":"slot_orig.heic","size":16384,"cloud":"local"}`)
+	defer SetTestExportOriginalJSON(`{"filename":"test.jpg","size":2048,"cloud":"cloud"}`)
+	bridge := &CgoBridge{}
+	result, err := bridge.ExportOriginalWithSlot("asset-1", "/tmp", 0, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Filename != "slot_orig.heic" {
+		t.Errorf("got filename %q", result.Filename)
+	}
+}
+
+func TestCgoBridgeExportPreviewErrorViaStub(t *testing.T) {
+	SetTestExportPreviewJSON(`{"error":"disk full","cloud":"local"}`)
+	defer SetTestExportPreviewJSON(`{"filename":"0000_test.jpg","size":1024,"cloud":"local"}`)
+	bridge := &CgoBridge{}
+	_, err := bridge.ExportPreview("asset-1", "/tmp", 1024, 85, 0)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if err.Error() != "disk full" {
+		t.Errorf("got error %q, want %q", err.Error(), "disk full")
+	}
+}
+
+func TestCgoBridgeExportOriginalErrorViaStub(t *testing.T) {
+	SetTestExportOriginalJSON(`{"error":"write failed","cloud":"local"}`)
+	defer SetTestExportOriginalJSON(`{"filename":"test.jpg","size":2048,"cloud":"cloud"}`)
+	bridge := &CgoBridge{}
+	_, err := bridge.ExportOriginal("asset-1", "/tmp", 0)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if err.Error() != "write failed" {
+		t.Errorf("got error %q, want %q", err.Error(), "write failed")
+	}
+}
+
+func TestCgoBridgeExportSkippedResult(t *testing.T) {
+	SetTestExportPreviewJSON(`{"filename":"skip.jpg","size":0,"cloud":"local","skipped":true}`)
+	defer SetTestExportPreviewJSON(`{"filename":"0000_test.jpg","size":1024,"cloud":"local"}`)
+	bridge := &CgoBridge{}
+	result, err := bridge.ExportPreview("asset-1", "/tmp", 1024, 85, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Skipped {
+		t.Error("expected Skipped to be true")
+	}
+}
+
+func TestCgoBridgeCancelAndIsCancelled(t *testing.T) {
+	bridge := &CgoBridge{}
+	if bridge.IsCancelled() {
+		t.Error("should not be cancelled initially")
+	}
+	bridge.Cancel()
+	if !bridge.IsCancelled() {
+		t.Error("should be cancelled after Cancel()")
+	}
+}
+
+func TestGetProgressSlotsReturnsSlots(t *testing.T) {
+	slots := GetProgressSlots()
+	if slots == nil {
+		t.Errorf("GetProgressSlots should return slots in test build")
+	}
+	if len(slots) != 16 {
+		t.Errorf("GetProgressSlots should return 16 slots, got %d", len(slots))
+	}
+}
+
+func TestResetProgressSlotsNoPanic(t *testing.T) {
+	ResetProgressSlots()
+}
+
+func TestGetProgressSlotCount(t *testing.T) {
+	count := GetProgressSlotCount()
+	if count != 16 {
+		t.Errorf("expected 16, got %d", count)
+	}
+}
+
+func TestCgoBridgeExportPreviewNilStub(t *testing.T) {
+	SetTestExportPreviewJSONNull()
+	defer SetTestExportPreviewJSON(`{"filename":"0000_test.jpg","size":1024,"cloud":"local"}`)
+	bridge := &CgoBridge{}
+	_, err := bridge.ExportPreview("asset-1", "/tmp", 1024, 85, 0)
+	if err == nil {
+		t.Fatal("expected errBridgeNil")
+	}
+	if err != errBridgeNil {
+		t.Errorf("got %v, want %v", err, errBridgeNil)
+	}
+}
+
+func TestCgoBridgeExportOriginalNilStub(t *testing.T) {
+	SetTestExportOriginalJSONNull()
+	defer SetTestExportOriginalJSON(`{"filename":"test.jpg","size":2048,"cloud":"cloud"}`)
+	bridge := &CgoBridge{}
+	_, err := bridge.ExportOriginal("asset-1", "/tmp", 0)
+	if err == nil {
+		t.Fatal("expected errBridgeNil")
+	}
+	if err != errBridgeNil {
+		t.Errorf("got %v, want %v", err, errBridgeNil)
+	}
+}
+
+func TestCgoBridgeExportPreviewWithSlotNilStub(t *testing.T) {
+	SetTestExportPreviewJSONNull()
+	defer SetTestExportPreviewJSON(`{"filename":"0000_test.jpg","size":1024,"cloud":"local"}`)
+	bridge := &CgoBridge{}
+	_, err := bridge.ExportPreviewWithSlot("asset-1", "/tmp", 1024, 85, 0, 0)
+	if err == nil {
+		t.Fatal("expected errBridgeNil")
+	}
+	if err != errBridgeNil {
+		t.Errorf("got %v, want %v", err, errBridgeNil)
+	}
+}
+
+func TestCgoBridgeExportOriginalWithSlotNilStub(t *testing.T) {
+	SetTestExportOriginalJSONNull()
+	defer SetTestExportOriginalJSON(`{"filename":"test.jpg","size":2048,"cloud":"cloud"}`)
+	bridge := &CgoBridge{}
+	_, err := bridge.ExportOriginalWithSlot("asset-1", "/tmp", 0, 0)
+	if err == nil {
+		t.Fatal("expected errBridgeNil")
+	}
+	if err != errBridgeNil {
+		t.Errorf("got %v, want %v", err, errBridgeNil)
+	}
+}
+
+func TestGetProgressSlotsWithActiveSlot(t *testing.T) {
+	ResetProgressSlots()
+	slots := GetProgressSlots()
+	if len(slots) != 16 {
+		t.Errorf("expected 16 slots, got %d", len(slots))
+	}
+	for i, s := range slots {
+		if s.Active {
+			t.Errorf("slot %d should not be active after reset", i)
+		}
+	}
+}
+
+func TestResetProgressSlotsClearsState(t *testing.T) {
+	ResetProgressSlots()
+	slots := GetProgressSlots()
+	if len(slots) > 0 && slots[0].Active {
+		t.Errorf("slot should be inactive after reset")
+	}
+}
+
+func TestGetProgressSlotsZeroCount(t *testing.T) {
+	SetTestProgressSlotCount(0)
+	defer SetTestProgressSlotCount(3)
+	slots := GetProgressSlots()
+	if slots != nil {
+		t.Errorf("expected nil with zero count, got %v", slots)
+	}
+}
+
+func TestGetProgressSlotsNullPointer(t *testing.T) {
+	SetTestProgressSlotsNull(1)
+	defer SetTestProgressSlotsNull(0)
+	slots := GetProgressSlots()
+	if slots != nil {
+		t.Errorf("expected nil with null pointer, got %v", slots)
+	}
+}
+
+func TestExportProgressSlotType(t *testing.T) {
+	slot := ExportProgressSlot{
+		Active:     true,
+		Progress:   0.75,
+		BytesDone:  512,
+		BytesTotal: 1024,
+	}
+	if !slot.Active {
+		t.Error("expected Active to be true")
+	}
+	if slot.Progress != 0.75 {
+		t.Errorf("expected Progress 0.75, got %f", slot.Progress)
+	}
+}

internal/photos/types.go

@@ -6,17 +6,17 @@ type Album struct {
 }
 
 type Asset struct {
-	ID             string           `json:"id"`
-	Filename       string           `json:"filename"`
-	Cloud          string           `json:"cloud"`
-	MediaType      string           `json:"mediaType"`
-	PixelWidth     int              `json:"pixelWidth"`
-	PixelHeight    int              `json:"pixelHeight"`
-	CreationDate   *string          `json:"creationDate,omitempty"`
-	Duration       float64          `json:"duration,omitempty"`
-	IsFavorite     bool             `json:"isFavorite,omitempty"`
-	HasAdjustments bool             `json:"hasAdjustments,omitempty"`
-	Resources      []AssetResource  `json:"resources,omitempty"`
+	ID             string          `json:"id"`
+	Filename       string          `json:"filename"`
+	Cloud          string          `json:"cloud"`
+	MediaType      string          `json:"mediaType"`
+	PixelWidth     int             `json:"pixelWidth"`
+	PixelHeight    int             `json:"pixelHeight"`
+	CreationDate   *string         `json:"creationDate,omitempty"`
+	Duration       float64         `json:"duration,omitempty"`
+	IsFavorite     bool            `json:"isFavorite,omitempty"`
+	HasAdjustments bool            `json:"hasAdjustments,omitempty"`
+	Resources      []AssetResource `json:"resources,omitempty"`
 }
 
 type AssetResource struct {