diff --git a/api/tangled/actorgetProfile.go b/api/tangled/actorgetProfile.go new file mode 100644 --- /dev/null +++ b/api/tangled/actorgetProfile.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.actor.getProfile + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + ActorGetProfileNSID = "sh.tangled.actor.getProfile" +) + +// ActorGetProfile_Output is the output of a sh.tangled.actor.getProfile call. +type ActorGetProfile_Output struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.actor.profile record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// ActorGetProfile calls the XRPC method "sh.tangled.actor.getProfile". +// +// actor: AT-URI of the sh.tangled.actor.profile record to fetch. +func ActorGetProfile(ctx context.Context, c util.LexClient, actor string) (*ActorGetProfile_Output, error) { + var out ActorGetProfile_Output + + params := map[string]interface{}{} + params["actor"] = actor + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.actor.getProfile", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/actorgetProfiles.go b/api/tangled/actorgetProfiles.go new file mode 100644 --- /dev/null +++ b/api/tangled/actorgetProfiles.go @@ -0,0 +1,43 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.actor.getProfiles + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + ActorGetProfilesNSID = "sh.tangled.actor.getProfiles" +) + +// ActorGetProfiles_Output is the output of a sh.tangled.actor.getProfiles call. +type ActorGetProfiles_Output struct { + Items []*ActorGetProfiles_RecordView `json:"items" cborgen:"items"` +} + +// ActorGetProfiles_RecordView is a "recordView" in the sh.tangled.actor.getProfiles schema. +type ActorGetProfiles_RecordView struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.actor.profile record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// ActorGetProfiles calls the XRPC method "sh.tangled.actor.getProfiles". +// +// actors: AT-URIs of the sh.tangled.actor.profile records to fetch. At most 50 per request. +func ActorGetProfiles(ctx context.Context, c util.LexClient, actors []string) (*ActorGetProfiles_Output, error) { + var out ActorGetProfiles_Output + + params := map[string]interface{}{} + params["actors"] = actors + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.actor.getProfiles", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedcountComments.go b/api/tangled/feedcountComments.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedcountComments.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.countComments + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedCountCommentsNSID = "sh.tangled.feed.countComments" +) + +// FeedCountComments_Output is the output of a sh.tangled.feed.countComments call. +type FeedCountComments_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// FeedCountComments calls the XRPC method "sh.tangled.feed.countComments". +// +// subject: Record AT-URI the comments attach to. +func FeedCountComments(ctx context.Context, c util.LexClient, subject string) (*FeedCountComments_Output, error) { + var out FeedCountComments_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.countComments", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedcountCommentsBy.go b/api/tangled/feedcountCommentsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedcountCommentsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.countCommentsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedCountCommentsByNSID = "sh.tangled.feed.countCommentsBy" +) + +// FeedCountCommentsBy_Output is the output of a sh.tangled.feed.countCommentsBy call. +type FeedCountCommentsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// FeedCountCommentsBy calls the XRPC method "sh.tangled.feed.countCommentsBy". +// +// subject: Actor DID whose comment authorings to list. +func FeedCountCommentsBy(ctx context.Context, c util.LexClient, subject string) (*FeedCountCommentsBy_Output, error) { + var out FeedCountCommentsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.countCommentsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedcountReactions.go b/api/tangled/feedcountReactions.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedcountReactions.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.countReactions + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedCountReactionsNSID = "sh.tangled.feed.countReactions" +) + +// FeedCountReactions_Output is the output of a sh.tangled.feed.countReactions call. +type FeedCountReactions_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// FeedCountReactions calls the XRPC method "sh.tangled.feed.countReactions". +// +// subject: Record AT-URI the reactions target. +func FeedCountReactions(ctx context.Context, c util.LexClient, subject string) (*FeedCountReactions_Output, error) { + var out FeedCountReactions_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.countReactions", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedcountReactionsBy.go b/api/tangled/feedcountReactionsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedcountReactionsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.countReactionsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedCountReactionsByNSID = "sh.tangled.feed.countReactionsBy" +) + +// FeedCountReactionsBy_Output is the output of a sh.tangled.feed.countReactionsBy call. +type FeedCountReactionsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// FeedCountReactionsBy calls the XRPC method "sh.tangled.feed.countReactionsBy". +// +// subject: Actor DID whose reaction authorings to list. +func FeedCountReactionsBy(ctx context.Context, c util.LexClient, subject string) (*FeedCountReactionsBy_Output, error) { + var out FeedCountReactionsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.countReactionsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedcountStars.go b/api/tangled/feedcountStars.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedcountStars.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.countStars + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedCountStarsNSID = "sh.tangled.feed.countStars" +) + +// FeedCountStars_Output is the output of a sh.tangled.feed.countStars call. +type FeedCountStars_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// FeedCountStars calls the XRPC method "sh.tangled.feed.countStars". +// +// subject: Repo DID to list star edges for. +func FeedCountStars(ctx context.Context, c util.LexClient, subject string) (*FeedCountStars_Output, error) { + var out FeedCountStars_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.countStars", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedcountStarsBy.go b/api/tangled/feedcountStarsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedcountStarsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.countStarsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedCountStarsByNSID = "sh.tangled.feed.countStarsBy" +) + +// FeedCountStarsBy_Output is the output of a sh.tangled.feed.countStarsBy call. +type FeedCountStarsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// FeedCountStarsBy calls the XRPC method "sh.tangled.feed.countStarsBy". +// +// subject: Actor DID whose star authorings to list. +func FeedCountStarsBy(ctx context.Context, c util.LexClient, subject string) (*FeedCountStarsBy_Output, error) { + var out FeedCountStarsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.countStarsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedlistComments.go b/api/tangled/feedlistComments.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedlistComments.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.listComments + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedListCommentsNSID = "sh.tangled.feed.listComments" +) + +// FeedListComments_ListItem is a "listItem" in the sh.tangled.feed.listComments schema. +type FeedListComments_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.feed.comment record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// FeedListComments_Output is the output of a sh.tangled.feed.listComments call. +type FeedListComments_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*FeedListComments_ListItem `json:"items" cborgen:"items"` +} + +// FeedListComments calls the XRPC method "sh.tangled.feed.listComments". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Record AT-URI the comments attach to. +func FeedListComments(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*FeedListComments_Output, error) { + var out FeedListComments_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.listComments", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedlistCommentsBy.go b/api/tangled/feedlistCommentsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedlistCommentsBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.listCommentsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedListCommentsByNSID = "sh.tangled.feed.listCommentsBy" +) + +// FeedListCommentsBy_Output is the output of a sh.tangled.feed.listCommentsBy call. +type FeedListCommentsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*FeedListComments_ListItem `json:"items" cborgen:"items"` +} + +// FeedListCommentsBy calls the XRPC method "sh.tangled.feed.listCommentsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose comment authorings to list. +func FeedListCommentsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*FeedListCommentsBy_Output, error) { + var out FeedListCommentsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.listCommentsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedlistReactions.go b/api/tangled/feedlistReactions.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedlistReactions.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.listReactions + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedListReactionsNSID = "sh.tangled.feed.listReactions" +) + +// FeedListReactions_ListItem is a "listItem" in the sh.tangled.feed.listReactions schema. +type FeedListReactions_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.feed.reaction record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// FeedListReactions_Output is the output of a sh.tangled.feed.listReactions call. +type FeedListReactions_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*FeedListReactions_ListItem `json:"items" cborgen:"items"` +} + +// FeedListReactions calls the XRPC method "sh.tangled.feed.listReactions". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Record AT-URI the reactions target. +func FeedListReactions(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*FeedListReactions_Output, error) { + var out FeedListReactions_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.listReactions", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedlistReactionsBy.go b/api/tangled/feedlistReactionsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedlistReactionsBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.listReactionsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedListReactionsByNSID = "sh.tangled.feed.listReactionsBy" +) + +// FeedListReactionsBy_Output is the output of a sh.tangled.feed.listReactionsBy call. +type FeedListReactionsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*FeedListReactions_ListItem `json:"items" cborgen:"items"` +} + +// FeedListReactionsBy calls the XRPC method "sh.tangled.feed.listReactionsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose reaction authorings to list. +func FeedListReactionsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*FeedListReactionsBy_Output, error) { + var out FeedListReactionsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.listReactionsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedlistStars.go b/api/tangled/feedlistStars.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedlistStars.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.listStars + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedListStarsNSID = "sh.tangled.feed.listStars" +) + +// FeedListStars_ListItem is a "listItem" in the sh.tangled.feed.listStars schema. +type FeedListStars_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.feed.star record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// FeedListStars_Output is the output of a sh.tangled.feed.listStars call. +type FeedListStars_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*FeedListStars_ListItem `json:"items" cborgen:"items"` +} + +// FeedListStars calls the XRPC method "sh.tangled.feed.listStars". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Repo DID to list star edges for. +func FeedListStars(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*FeedListStars_Output, error) { + var out FeedListStars_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.listStars", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/feedlistStarsBy.go b/api/tangled/feedlistStarsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/feedlistStarsBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.feed.listStarsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + FeedListStarsByNSID = "sh.tangled.feed.listStarsBy" +) + +// FeedListStarsBy_Output is the output of a sh.tangled.feed.listStarsBy call. +type FeedListStarsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*FeedListStars_ListItem `json:"items" cborgen:"items"` +} + +// FeedListStarsBy calls the XRPC method "sh.tangled.feed.listStarsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose star authorings to list. +func FeedListStarsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*FeedListStarsBy_Output, error) { + var out FeedListStarsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.feed.listStarsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/gitcountRefUpdates.go b/api/tangled/gitcountRefUpdates.go new file mode 100644 --- /dev/null +++ b/api/tangled/gitcountRefUpdates.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.git.countRefUpdates + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GitCountRefUpdatesNSID = "sh.tangled.git.countRefUpdates" +) + +// GitCountRefUpdates_Output is the output of a sh.tangled.git.countRefUpdates call. +type GitCountRefUpdates_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// GitCountRefUpdates calls the XRPC method "sh.tangled.git.countRefUpdates". +// +// subject: Repo DID whose ref-update records to list. +func GitCountRefUpdates(ctx context.Context, c util.LexClient, subject string) (*GitCountRefUpdates_Output, error) { + var out GitCountRefUpdates_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.git.countRefUpdates", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/gitcountRefUpdatesBy.go b/api/tangled/gitcountRefUpdatesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/gitcountRefUpdatesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.git.countRefUpdatesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GitCountRefUpdatesByNSID = "sh.tangled.git.countRefUpdatesBy" +) + +// GitCountRefUpdatesBy_Output is the output of a sh.tangled.git.countRefUpdatesBy call. +type GitCountRefUpdatesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// GitCountRefUpdatesBy calls the XRPC method "sh.tangled.git.countRefUpdatesBy". +// +// subject: Actor DID whose ref-update authorings to list. +func GitCountRefUpdatesBy(ctx context.Context, c util.LexClient, subject string) (*GitCountRefUpdatesBy_Output, error) { + var out GitCountRefUpdatesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.git.countRefUpdatesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/gitlistRefUpdates.go b/api/tangled/gitlistRefUpdates.go new file mode 100644 --- /dev/null +++ b/api/tangled/gitlistRefUpdates.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.git.listRefUpdates + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GitListRefUpdatesNSID = "sh.tangled.git.listRefUpdates" +) + +// GitListRefUpdates_ListItem is a "listItem" in the sh.tangled.git.listRefUpdates schema. +type GitListRefUpdates_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.git.refUpdate record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// GitListRefUpdates_Output is the output of a sh.tangled.git.listRefUpdates call. +type GitListRefUpdates_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*GitListRefUpdates_ListItem `json:"items" cborgen:"items"` +} + +// GitListRefUpdates calls the XRPC method "sh.tangled.git.listRefUpdates". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Repo DID whose ref-update records to list. +func GitListRefUpdates(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*GitListRefUpdates_Output, error) { + var out GitListRefUpdates_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.git.listRefUpdates", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/gitlistRefUpdatesBy.go b/api/tangled/gitlistRefUpdatesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/gitlistRefUpdatesBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.git.listRefUpdatesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GitListRefUpdatesByNSID = "sh.tangled.git.listRefUpdatesBy" +) + +// GitListRefUpdatesBy_Output is the output of a sh.tangled.git.listRefUpdatesBy call. +type GitListRefUpdatesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*GitListRefUpdates_ListItem `json:"items" cborgen:"items"` +} + +// GitListRefUpdatesBy calls the XRPC method "sh.tangled.git.listRefUpdatesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose ref-update authorings to list. +func GitListRefUpdatesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*GitListRefUpdatesBy_Output, error) { + var out GitListRefUpdatesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.git.listRefUpdatesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphcountFollows.go b/api/tangled/graphcountFollows.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphcountFollows.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.countFollows + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphCountFollowsNSID = "sh.tangled.graph.countFollows" +) + +// GraphCountFollows_Output is the output of a sh.tangled.graph.countFollows call. +type GraphCountFollows_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// GraphCountFollows calls the XRPC method "sh.tangled.graph.countFollows". +// +// subject: Followee DID whose inbound follows to list. +func GraphCountFollows(ctx context.Context, c util.LexClient, subject string) (*GraphCountFollows_Output, error) { + var out GraphCountFollows_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.countFollows", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphcountFollowsBy.go b/api/tangled/graphcountFollowsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphcountFollowsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.countFollowsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphCountFollowsByNSID = "sh.tangled.graph.countFollowsBy" +) + +// GraphCountFollowsBy_Output is the output of a sh.tangled.graph.countFollowsBy call. +type GraphCountFollowsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// GraphCountFollowsBy calls the XRPC method "sh.tangled.graph.countFollowsBy". +// +// subject: Actor DID whose follow authorings to list. +func GraphCountFollowsBy(ctx context.Context, c util.LexClient, subject string) (*GraphCountFollowsBy_Output, error) { + var out GraphCountFollowsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.countFollowsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphcountVouches.go b/api/tangled/graphcountVouches.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphcountVouches.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.countVouches + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphCountVouchesNSID = "sh.tangled.graph.countVouches" +) + +// GraphCountVouches_Output is the output of a sh.tangled.graph.countVouches call. +type GraphCountVouches_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// GraphCountVouches calls the XRPC method "sh.tangled.graph.countVouches". +// +// subject: Vouchee DID whose inbound vouches to list. +func GraphCountVouches(ctx context.Context, c util.LexClient, subject string) (*GraphCountVouches_Output, error) { + var out GraphCountVouches_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.countVouches", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphcountVouchesBy.go b/api/tangled/graphcountVouchesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphcountVouchesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.countVouchesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphCountVouchesByNSID = "sh.tangled.graph.countVouchesBy" +) + +// GraphCountVouchesBy_Output is the output of a sh.tangled.graph.countVouchesBy call. +type GraphCountVouchesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// GraphCountVouchesBy calls the XRPC method "sh.tangled.graph.countVouchesBy". +// +// subject: Actor DID whose vouch authorings to list. +func GraphCountVouchesBy(ctx context.Context, c util.LexClient, subject string) (*GraphCountVouchesBy_Output, error) { + var out GraphCountVouchesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.countVouchesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphlistFollows.go b/api/tangled/graphlistFollows.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphlistFollows.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.listFollows + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphListFollowsNSID = "sh.tangled.graph.listFollows" +) + +// GraphListFollows_ListItem is a "listItem" in the sh.tangled.graph.listFollows schema. +type GraphListFollows_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.graph.follow record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// GraphListFollows_Output is the output of a sh.tangled.graph.listFollows call. +type GraphListFollows_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*GraphListFollows_ListItem `json:"items" cborgen:"items"` +} + +// GraphListFollows calls the XRPC method "sh.tangled.graph.listFollows". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Followee DID whose inbound follows to list. +func GraphListFollows(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*GraphListFollows_Output, error) { + var out GraphListFollows_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.listFollows", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphlistFollowsBy.go b/api/tangled/graphlistFollowsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphlistFollowsBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.listFollowsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphListFollowsByNSID = "sh.tangled.graph.listFollowsBy" +) + +// GraphListFollowsBy_Output is the output of a sh.tangled.graph.listFollowsBy call. +type GraphListFollowsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*GraphListFollows_ListItem `json:"items" cborgen:"items"` +} + +// GraphListFollowsBy calls the XRPC method "sh.tangled.graph.listFollowsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose follow authorings to list. +func GraphListFollowsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*GraphListFollowsBy_Output, error) { + var out GraphListFollowsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.listFollowsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphlistVouches.go b/api/tangled/graphlistVouches.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphlistVouches.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.listVouches + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphListVouchesNSID = "sh.tangled.graph.listVouches" +) + +// GraphListVouches_ListItem is a "listItem" in the sh.tangled.graph.listVouches schema. +type GraphListVouches_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.graph.vouch record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// GraphListVouches_Output is the output of a sh.tangled.graph.listVouches call. +type GraphListVouches_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*GraphListVouches_ListItem `json:"items" cborgen:"items"` +} + +// GraphListVouches calls the XRPC method "sh.tangled.graph.listVouches". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Vouchee DID whose inbound vouches to list. +func GraphListVouches(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*GraphListVouches_Output, error) { + var out GraphListVouches_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.listVouches", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/graphlistVouchesBy.go b/api/tangled/graphlistVouchesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/graphlistVouchesBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.graph.listVouchesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + GraphListVouchesByNSID = "sh.tangled.graph.listVouchesBy" +) + +// GraphListVouchesBy_Output is the output of a sh.tangled.graph.listVouchesBy call. +type GraphListVouchesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*GraphListVouches_ListItem `json:"items" cborgen:"items"` +} + +// GraphListVouchesBy calls the XRPC method "sh.tangled.graph.listVouchesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose vouch authorings to list. +func GraphListVouchesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*GraphListVouchesBy_Output, error) { + var out GraphListVouchesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.graph.listVouchesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/issuecountStates.go b/api/tangled/issuecountStates.go new file mode 100644 --- /dev/null +++ b/api/tangled/issuecountStates.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.issue.countStates + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoIssueCountStatesNSID = "sh.tangled.repo.issue.countStates" +) + +// RepoIssueCountStates_Output is the output of a sh.tangled.repo.issue.countStates call. +type RepoIssueCountStates_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoIssueCountStates calls the XRPC method "sh.tangled.repo.issue.countStates". +// +// subject: Issue AT-URI whose state records to list. +func RepoIssueCountStates(ctx context.Context, c util.LexClient, subject string) (*RepoIssueCountStates_Output, error) { + var out RepoIssueCountStates_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.issue.countStates", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/issuecountStatesBy.go b/api/tangled/issuecountStatesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/issuecountStatesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.issue.countStatesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoIssueCountStatesByNSID = "sh.tangled.repo.issue.countStatesBy" +) + +// RepoIssueCountStatesBy_Output is the output of a sh.tangled.repo.issue.countStatesBy call. +type RepoIssueCountStatesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoIssueCountStatesBy calls the XRPC method "sh.tangled.repo.issue.countStatesBy". +// +// subject: Actor DID whose issue-state authorings to list. +func RepoIssueCountStatesBy(ctx context.Context, c util.LexClient, subject string) (*RepoIssueCountStatesBy_Output, error) { + var out RepoIssueCountStatesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.issue.countStatesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/issuelistStates.go b/api/tangled/issuelistStates.go new file mode 100644 --- /dev/null +++ b/api/tangled/issuelistStates.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.issue.listStates + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoIssueListStatesNSID = "sh.tangled.repo.issue.listStates" +) + +// RepoIssueListStates_ListItem is a "listItem" in the sh.tangled.repo.issue.listStates schema. +type RepoIssueListStates_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.issue.state record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoIssueListStates_Output is the output of a sh.tangled.repo.issue.listStates call. +type RepoIssueListStates_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoIssueListStates_ListItem `json:"items" cborgen:"items"` +} + +// RepoIssueListStates calls the XRPC method "sh.tangled.repo.issue.listStates". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Issue AT-URI whose state records to list. +func RepoIssueListStates(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoIssueListStates_Output, error) { + var out RepoIssueListStates_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.issue.listStates", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/issuelistStatesBy.go b/api/tangled/issuelistStatesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/issuelistStatesBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.issue.listStatesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoIssueListStatesByNSID = "sh.tangled.repo.issue.listStatesBy" +) + +// RepoIssueListStatesBy_Output is the output of a sh.tangled.repo.issue.listStatesBy call. +type RepoIssueListStatesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoIssueListStates_ListItem `json:"items" cborgen:"items"` +} + +// RepoIssueListStatesBy calls the XRPC method "sh.tangled.repo.issue.listStatesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose issue-state authorings to list. +func RepoIssueListStatesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoIssueListStatesBy_Output, error) { + var out RepoIssueListStatesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.issue.listStatesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/knotcountKnots.go b/api/tangled/knotcountKnots.go new file mode 100644 --- /dev/null +++ b/api/tangled/knotcountKnots.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.knot.countKnots + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + KnotCountKnotsNSID = "sh.tangled.knot.countKnots" +) + +// KnotCountKnots_Output is the output of a sh.tangled.knot.countKnots call. +type KnotCountKnots_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// KnotCountKnots calls the XRPC method "sh.tangled.knot.countKnots". +// +// subject: Owner DID whose knot records to list. +func KnotCountKnots(ctx context.Context, c util.LexClient, subject string) (*KnotCountKnots_Output, error) { + var out KnotCountKnots_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.countKnots", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/knotcountMembers.go b/api/tangled/knotcountMembers.go new file mode 100644 --- /dev/null +++ b/api/tangled/knotcountMembers.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.knot.countMembers + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + KnotCountMembersNSID = "sh.tangled.knot.countMembers" +) + +// KnotCountMembers_Output is the output of a sh.tangled.knot.countMembers call. +type KnotCountMembers_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// KnotCountMembers calls the XRPC method "sh.tangled.knot.countMembers". +// +// subject: Knot identifier whose member records to list. +func KnotCountMembers(ctx context.Context, c util.LexClient, subject string) (*KnotCountMembers_Output, error) { + var out KnotCountMembers_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.countMembers", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/knotcountMembersBy.go b/api/tangled/knotcountMembersBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/knotcountMembersBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.knot.countMembersBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + KnotCountMembersByNSID = "sh.tangled.knot.countMembersBy" +) + +// KnotCountMembersBy_Output is the output of a sh.tangled.knot.countMembersBy call. +type KnotCountMembersBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// KnotCountMembersBy calls the XRPC method "sh.tangled.knot.countMembersBy". +// +// subject: Actor DID whose knot-member authorings to list. +func KnotCountMembersBy(ctx context.Context, c util.LexClient, subject string) (*KnotCountMembersBy_Output, error) { + var out KnotCountMembersBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.countMembersBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/knotlistKnots.go b/api/tangled/knotlistKnots.go new file mode 100644 --- /dev/null +++ b/api/tangled/knotlistKnots.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.knot.listKnots + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + KnotListKnotsNSID = "sh.tangled.knot.listKnots" +) + +// KnotListKnots_ListItem is a "listItem" in the sh.tangled.knot.listKnots schema. +type KnotListKnots_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.knot record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// KnotListKnots_Output is the output of a sh.tangled.knot.listKnots call. +type KnotListKnots_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*KnotListKnots_ListItem `json:"items" cborgen:"items"` +} + +// KnotListKnots calls the XRPC method "sh.tangled.knot.listKnots". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Owner DID whose knot records to list. +func KnotListKnots(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*KnotListKnots_Output, error) { + var out KnotListKnots_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.listKnots", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/labelcountDefinitions.go b/api/tangled/labelcountDefinitions.go new file mode 100644 --- /dev/null +++ b/api/tangled/labelcountDefinitions.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.countDefinitions + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelCountDefinitionsNSID = "sh.tangled.label.countDefinitions" +) + +// LabelCountDefinitions_Output is the output of a sh.tangled.label.countDefinitions call. +type LabelCountDefinitions_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// LabelCountDefinitions calls the XRPC method "sh.tangled.label.countDefinitions". +// +// subject: Scope identifier whose label definitions to list. +func LabelCountDefinitions(ctx context.Context, c util.LexClient, subject string) (*LabelCountDefinitions_Output, error) { + var out LabelCountDefinitions_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.label.countDefinitions", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/labelcountOps.go b/api/tangled/labelcountOps.go new file mode 100644 --- /dev/null +++ b/api/tangled/labelcountOps.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.countOps + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelCountOpsNSID = "sh.tangled.label.countOps" +) + +// LabelCountOps_Output is the output of a sh.tangled.label.countOps call. +type LabelCountOps_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// LabelCountOps calls the XRPC method "sh.tangled.label.countOps". +// +// subject: Scope identifier whose label op records to list. +func LabelCountOps(ctx context.Context, c util.LexClient, subject string) (*LabelCountOps_Output, error) { + var out LabelCountOps_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.label.countOps", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/labelcountOpsBy.go b/api/tangled/labelcountOpsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/labelcountOpsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.countOpsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelCountOpsByNSID = "sh.tangled.label.countOpsBy" +) + +// LabelCountOpsBy_Output is the output of a sh.tangled.label.countOpsBy call. +type LabelCountOpsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// LabelCountOpsBy calls the XRPC method "sh.tangled.label.countOpsBy". +// +// subject: Actor DID whose label-op authorings to list. +func LabelCountOpsBy(ctx context.Context, c util.LexClient, subject string) (*LabelCountOpsBy_Output, error) { + var out LabelCountOpsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.label.countOpsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/labellistDefinitions.go b/api/tangled/labellistDefinitions.go new file mode 100644 --- /dev/null +++ b/api/tangled/labellistDefinitions.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.listDefinitions + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelListDefinitionsNSID = "sh.tangled.label.listDefinitions" +) + +// LabelListDefinitions_ListItem is a "listItem" in the sh.tangled.label.listDefinitions schema. +type LabelListDefinitions_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.label.definition record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// LabelListDefinitions_Output is the output of a sh.tangled.label.listDefinitions call. +type LabelListDefinitions_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*LabelListDefinitions_ListItem `json:"items" cborgen:"items"` +} + +// LabelListDefinitions calls the XRPC method "sh.tangled.label.listDefinitions". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Scope identifier whose label definitions to list. +func LabelListDefinitions(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*LabelListDefinitions_Output, error) { + var out LabelListDefinitions_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.label.listDefinitions", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/labellistOps.go b/api/tangled/labellistOps.go new file mode 100644 --- /dev/null +++ b/api/tangled/labellistOps.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.listOps + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelListOpsNSID = "sh.tangled.label.listOps" +) + +// LabelListOps_ListItem is a "listItem" in the sh.tangled.label.listOps schema. +type LabelListOps_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.label.op record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// LabelListOps_Output is the output of a sh.tangled.label.listOps call. +type LabelListOps_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*LabelListOps_ListItem `json:"items" cborgen:"items"` +} + +// LabelListOps calls the XRPC method "sh.tangled.label.listOps". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Scope identifier whose label op records to list. +func LabelListOps(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*LabelListOps_Output, error) { + var out LabelListOps_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.label.listOps", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/labellistOpsBy.go b/api/tangled/labellistOpsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/labellistOpsBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.label.listOpsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + LabelListOpsByNSID = "sh.tangled.label.listOpsBy" +) + +// LabelListOpsBy_Output is the output of a sh.tangled.label.listOpsBy call. +type LabelListOpsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*LabelListOps_ListItem `json:"items" cborgen:"items"` +} + +// LabelListOpsBy calls the XRPC method "sh.tangled.label.listOpsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose label-op authorings to list. +func LabelListOpsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*LabelListOpsBy_Output, error) { + var out LabelListOpsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.label.listOpsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinecountPipelines.go b/api/tangled/pipelinecountPipelines.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinecountPipelines.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.countPipelines + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineCountPipelinesNSID = "sh.tangled.pipeline.countPipelines" +) + +// PipelineCountPipelines_Output is the output of a sh.tangled.pipeline.countPipelines call. +type PipelineCountPipelines_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// PipelineCountPipelines calls the XRPC method "sh.tangled.pipeline.countPipelines". +// +// subject: Repo or spindle identifier whose pipeline records to list. +func PipelineCountPipelines(ctx context.Context, c util.LexClient, subject string) (*PipelineCountPipelines_Output, error) { + var out PipelineCountPipelines_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.countPipelines", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinecountPipelinesBy.go b/api/tangled/pipelinecountPipelinesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinecountPipelinesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.countPipelinesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineCountPipelinesByNSID = "sh.tangled.pipeline.countPipelinesBy" +) + +// PipelineCountPipelinesBy_Output is the output of a sh.tangled.pipeline.countPipelinesBy call. +type PipelineCountPipelinesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// PipelineCountPipelinesBy calls the XRPC method "sh.tangled.pipeline.countPipelinesBy". +// +// subject: Actor DID whose pipeline authorings to list. +func PipelineCountPipelinesBy(ctx context.Context, c util.LexClient, subject string) (*PipelineCountPipelinesBy_Output, error) { + var out PipelineCountPipelinesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.countPipelinesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinecountStatuses.go b/api/tangled/pipelinecountStatuses.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinecountStatuses.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.countStatuses + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineCountStatusesNSID = "sh.tangled.pipeline.countStatuses" +) + +// PipelineCountStatuses_Output is the output of a sh.tangled.pipeline.countStatuses call. +type PipelineCountStatuses_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// PipelineCountStatuses calls the XRPC method "sh.tangled.pipeline.countStatuses". +// +// subject: Pipeline AT-URI whose status records to list. +func PipelineCountStatuses(ctx context.Context, c util.LexClient, subject string) (*PipelineCountStatuses_Output, error) { + var out PipelineCountStatuses_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.countStatuses", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinecountStatusesBy.go b/api/tangled/pipelinecountStatusesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinecountStatusesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.countStatusesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineCountStatusesByNSID = "sh.tangled.pipeline.countStatusesBy" +) + +// PipelineCountStatusesBy_Output is the output of a sh.tangled.pipeline.countStatusesBy call. +type PipelineCountStatusesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// PipelineCountStatusesBy calls the XRPC method "sh.tangled.pipeline.countStatusesBy". +// +// subject: Actor DID whose pipeline-status authorings to list. +func PipelineCountStatusesBy(ctx context.Context, c util.LexClient, subject string) (*PipelineCountStatusesBy_Output, error) { + var out PipelineCountStatusesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.countStatusesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinelistPipelines.go b/api/tangled/pipelinelistPipelines.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinelistPipelines.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.listPipelines + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineListPipelinesNSID = "sh.tangled.pipeline.listPipelines" +) + +// PipelineListPipelines_ListItem is a "listItem" in the sh.tangled.pipeline.listPipelines schema. +type PipelineListPipelines_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.pipeline record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// PipelineListPipelines_Output is the output of a sh.tangled.pipeline.listPipelines call. +type PipelineListPipelines_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*PipelineListPipelines_ListItem `json:"items" cborgen:"items"` +} + +// PipelineListPipelines calls the XRPC method "sh.tangled.pipeline.listPipelines". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Repo or spindle identifier whose pipeline records to list. +func PipelineListPipelines(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*PipelineListPipelines_Output, error) { + var out PipelineListPipelines_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.listPipelines", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinelistPipelinesBy.go b/api/tangled/pipelinelistPipelinesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinelistPipelinesBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.listPipelinesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineListPipelinesByNSID = "sh.tangled.pipeline.listPipelinesBy" +) + +// PipelineListPipelinesBy_Output is the output of a sh.tangled.pipeline.listPipelinesBy call. +type PipelineListPipelinesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*PipelineListPipelines_ListItem `json:"items" cborgen:"items"` +} + +// PipelineListPipelinesBy calls the XRPC method "sh.tangled.pipeline.listPipelinesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose pipeline authorings to list. +func PipelineListPipelinesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*PipelineListPipelinesBy_Output, error) { + var out PipelineListPipelinesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.listPipelinesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinelistStatuses.go b/api/tangled/pipelinelistStatuses.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinelistStatuses.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.listStatuses + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineListStatusesNSID = "sh.tangled.pipeline.listStatuses" +) + +// PipelineListStatuses_ListItem is a "listItem" in the sh.tangled.pipeline.listStatuses schema. +type PipelineListStatuses_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.pipeline.status record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// PipelineListStatuses_Output is the output of a sh.tangled.pipeline.listStatuses call. +type PipelineListStatuses_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*PipelineListStatuses_ListItem `json:"items" cborgen:"items"` +} + +// PipelineListStatuses calls the XRPC method "sh.tangled.pipeline.listStatuses". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Pipeline AT-URI whose status records to list. +func PipelineListStatuses(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*PipelineListStatuses_Output, error) { + var out PipelineListStatuses_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.listStatuses", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pipelinelistStatusesBy.go b/api/tangled/pipelinelistStatusesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/pipelinelistStatusesBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.pipeline.listStatusesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PipelineListStatusesByNSID = "sh.tangled.pipeline.listStatusesBy" +) + +// PipelineListStatusesBy_Output is the output of a sh.tangled.pipeline.listStatusesBy call. +type PipelineListStatusesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*PipelineListStatuses_ListItem `json:"items" cborgen:"items"` +} + +// PipelineListStatusesBy calls the XRPC method "sh.tangled.pipeline.listStatusesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose pipeline-status authorings to list. +func PipelineListStatusesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*PipelineListStatusesBy_Output, error) { + var out PipelineListStatusesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.pipeline.listStatusesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/publicKeycountKeys.go b/api/tangled/publicKeycountKeys.go new file mode 100644 --- /dev/null +++ b/api/tangled/publicKeycountKeys.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.publicKey.countKeys + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PublicKeyCountKeysNSID = "sh.tangled.publicKey.countKeys" +) + +// PublicKeyCountKeys_Output is the output of a sh.tangled.publicKey.countKeys call. +type PublicKeyCountKeys_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// PublicKeyCountKeys calls the XRPC method "sh.tangled.publicKey.countKeys". +// +// subject: Owner DID whose public-key records to list. +func PublicKeyCountKeys(ctx context.Context, c util.LexClient, subject string) (*PublicKeyCountKeys_Output, error) { + var out PublicKeyCountKeys_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.publicKey.countKeys", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/publicKeylistKeys.go b/api/tangled/publicKeylistKeys.go new file mode 100644 --- /dev/null +++ b/api/tangled/publicKeylistKeys.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.publicKey.listKeys + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + PublicKeyListKeysNSID = "sh.tangled.publicKey.listKeys" +) + +// PublicKeyListKeys_ListItem is a "listItem" in the sh.tangled.publicKey.listKeys schema. +type PublicKeyListKeys_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.publicKey record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// PublicKeyListKeys_Output is the output of a sh.tangled.publicKey.listKeys call. +type PublicKeyListKeys_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*PublicKeyListKeys_ListItem `json:"items" cborgen:"items"` +} + +// PublicKeyListKeys calls the XRPC method "sh.tangled.publicKey.listKeys". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Owner DID whose public-key records to list. +func PublicKeyListKeys(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*PublicKeyListKeys_Output, error) { + var out PublicKeyListKeys_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.publicKey.listKeys", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pullcountStatuses.go b/api/tangled/pullcountStatuses.go new file mode 100644 --- /dev/null +++ b/api/tangled/pullcountStatuses.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.pull.countStatuses + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoPullCountStatusesNSID = "sh.tangled.repo.pull.countStatuses" +) + +// RepoPullCountStatuses_Output is the output of a sh.tangled.repo.pull.countStatuses call. +type RepoPullCountStatuses_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoPullCountStatuses calls the XRPC method "sh.tangled.repo.pull.countStatuses". +// +// subject: Pull AT-URI whose status records to list. +func RepoPullCountStatuses(ctx context.Context, c util.LexClient, subject string) (*RepoPullCountStatuses_Output, error) { + var out RepoPullCountStatuses_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.pull.countStatuses", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pullcountStatusesBy.go b/api/tangled/pullcountStatusesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/pullcountStatusesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.pull.countStatusesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoPullCountStatusesByNSID = "sh.tangled.repo.pull.countStatusesBy" +) + +// RepoPullCountStatusesBy_Output is the output of a sh.tangled.repo.pull.countStatusesBy call. +type RepoPullCountStatusesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoPullCountStatusesBy calls the XRPC method "sh.tangled.repo.pull.countStatusesBy". +// +// subject: Actor DID whose pull-status authorings to list. +func RepoPullCountStatusesBy(ctx context.Context, c util.LexClient, subject string) (*RepoPullCountStatusesBy_Output, error) { + var out RepoPullCountStatusesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.pull.countStatusesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pulllistStatuses.go b/api/tangled/pulllistStatuses.go new file mode 100644 --- /dev/null +++ b/api/tangled/pulllistStatuses.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.pull.listStatuses + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoPullListStatusesNSID = "sh.tangled.repo.pull.listStatuses" +) + +// RepoPullListStatuses_ListItem is a "listItem" in the sh.tangled.repo.pull.listStatuses schema. +type RepoPullListStatuses_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.pull.status record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoPullListStatuses_Output is the output of a sh.tangled.repo.pull.listStatuses call. +type RepoPullListStatuses_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoPullListStatuses_ListItem `json:"items" cborgen:"items"` +} + +// RepoPullListStatuses calls the XRPC method "sh.tangled.repo.pull.listStatuses". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Pull AT-URI whose status records to list. +func RepoPullListStatuses(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoPullListStatuses_Output, error) { + var out RepoPullListStatuses_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.pull.listStatuses", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/pulllistStatusesBy.go b/api/tangled/pulllistStatusesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/pulllistStatusesBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.pull.listStatusesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoPullListStatusesByNSID = "sh.tangled.repo.pull.listStatusesBy" +) + +// RepoPullListStatusesBy_Output is the output of a sh.tangled.repo.pull.listStatusesBy call. +type RepoPullListStatusesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoPullListStatuses_ListItem `json:"items" cborgen:"items"` +} + +// RepoPullListStatusesBy calls the XRPC method "sh.tangled.repo.pull.listStatusesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose pull-status authorings to list. +func RepoPullListStatusesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoPullListStatusesBy_Output, error) { + var out RepoPullListStatusesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.pull.listStatusesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountArtifacts.go b/api/tangled/repocountArtifacts.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountArtifacts.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countArtifacts + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountArtifactsNSID = "sh.tangled.repo.countArtifacts" +) + +// RepoCountArtifacts_Output is the output of a sh.tangled.repo.countArtifacts call. +type RepoCountArtifacts_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountArtifacts calls the XRPC method "sh.tangled.repo.countArtifacts". +// +// subject: Repo or release identifier whose artifacts to list. +func RepoCountArtifacts(ctx context.Context, c util.LexClient, subject string) (*RepoCountArtifacts_Output, error) { + var out RepoCountArtifacts_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countArtifacts", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountArtifactsBy.go b/api/tangled/repocountArtifactsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountArtifactsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countArtifactsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountArtifactsByNSID = "sh.tangled.repo.countArtifactsBy" +) + +// RepoCountArtifactsBy_Output is the output of a sh.tangled.repo.countArtifactsBy call. +type RepoCountArtifactsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountArtifactsBy calls the XRPC method "sh.tangled.repo.countArtifactsBy". +// +// subject: Actor DID whose artifact authorings to list. +func RepoCountArtifactsBy(ctx context.Context, c util.LexClient, subject string) (*RepoCountArtifactsBy_Output, error) { + var out RepoCountArtifactsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countArtifactsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountCollaborators.go b/api/tangled/repocountCollaborators.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountCollaborators.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countCollaborators + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountCollaboratorsNSID = "sh.tangled.repo.countCollaborators" +) + +// RepoCountCollaborators_Output is the output of a sh.tangled.repo.countCollaborators call. +type RepoCountCollaborators_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountCollaborators calls the XRPC method "sh.tangled.repo.countCollaborators". +// +// subject: Repo DID whose collaborator records to list. +func RepoCountCollaborators(ctx context.Context, c util.LexClient, subject string) (*RepoCountCollaborators_Output, error) { + var out RepoCountCollaborators_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countCollaborators", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountCollaboratorsBy.go b/api/tangled/repocountCollaboratorsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountCollaboratorsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countCollaboratorsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountCollaboratorsByNSID = "sh.tangled.repo.countCollaboratorsBy" +) + +// RepoCountCollaboratorsBy_Output is the output of a sh.tangled.repo.countCollaboratorsBy call. +type RepoCountCollaboratorsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountCollaboratorsBy calls the XRPC method "sh.tangled.repo.countCollaboratorsBy". +// +// subject: Actor DID whose collaborator authorings to list. +func RepoCountCollaboratorsBy(ctx context.Context, c util.LexClient, subject string) (*RepoCountCollaboratorsBy_Output, error) { + var out RepoCountCollaboratorsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countCollaboratorsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountIssues.go b/api/tangled/repocountIssues.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountIssues.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countIssues + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountIssuesNSID = "sh.tangled.repo.countIssues" +) + +// RepoCountIssues_Output is the output of a sh.tangled.repo.countIssues call. +type RepoCountIssues_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountIssues calls the XRPC method "sh.tangled.repo.countIssues". +// +// subject: Repo DID to list issues for +func RepoCountIssues(ctx context.Context, c util.LexClient, subject string) (*RepoCountIssues_Output, error) { + var out RepoCountIssues_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countIssues", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountIssuesBy.go b/api/tangled/repocountIssuesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountIssuesBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countIssuesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountIssuesByNSID = "sh.tangled.repo.countIssuesBy" +) + +// RepoCountIssuesBy_Output is the output of a sh.tangled.repo.countIssuesBy call. +type RepoCountIssuesBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountIssuesBy calls the XRPC method "sh.tangled.repo.countIssuesBy". +// +// subject: Actor DID whose issue authorings to list +func RepoCountIssuesBy(ctx context.Context, c util.LexClient, subject string) (*RepoCountIssuesBy_Output, error) { + var out RepoCountIssuesBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countIssuesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountPulls.go b/api/tangled/repocountPulls.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountPulls.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countPulls + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountPullsNSID = "sh.tangled.repo.countPulls" +) + +// RepoCountPulls_Output is the output of a sh.tangled.repo.countPulls call. +type RepoCountPulls_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountPulls calls the XRPC method "sh.tangled.repo.countPulls". +// +// subject: Repo DID to list pulls for +func RepoCountPulls(ctx context.Context, c util.LexClient, subject string) (*RepoCountPulls_Output, error) { + var out RepoCountPulls_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countPulls", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountPullsBy.go b/api/tangled/repocountPullsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountPullsBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countPullsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountPullsByNSID = "sh.tangled.repo.countPullsBy" +) + +// RepoCountPullsBy_Output is the output of a sh.tangled.repo.countPullsBy call. +type RepoCountPullsBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountPullsBy calls the XRPC method "sh.tangled.repo.countPullsBy". +// +// subject: Actor DID whose pull authorings to list +func RepoCountPullsBy(ctx context.Context, c util.LexClient, subject string) (*RepoCountPullsBy_Output, error) { + var out RepoCountPullsBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countPullsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repocountRepos.go b/api/tangled/repocountRepos.go new file mode 100644 --- /dev/null +++ b/api/tangled/repocountRepos.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.countRepos + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoCountReposNSID = "sh.tangled.repo.countRepos" +) + +// RepoCountRepos_Output is the output of a sh.tangled.repo.countRepos call. +type RepoCountRepos_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// RepoCountRepos calls the XRPC method "sh.tangled.repo.countRepos". +// +// subject: Owner DID whose repo records to list. +func RepoCountRepos(ctx context.Context, c util.LexClient, subject string) (*RepoCountRepos_Output, error) { + var out RepoCountRepos_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.countRepos", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetIssue.go b/api/tangled/repogetIssue.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetIssue.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getIssue + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetIssueNSID = "sh.tangled.repo.getIssue" +) + +// RepoGetIssue_Output is the output of a sh.tangled.repo.getIssue call. +type RepoGetIssue_Output struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.issue record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetIssue calls the XRPC method "sh.tangled.repo.getIssue". +// +// issue: AT-URI of the sh.tangled.repo.issue record to fetch. +func RepoGetIssue(ctx context.Context, c util.LexClient, issue string) (*RepoGetIssue_Output, error) { + var out RepoGetIssue_Output + + params := map[string]interface{}{} + params["issue"] = issue + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getIssue", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetIssues.go b/api/tangled/repogetIssues.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetIssues.go @@ -0,0 +1,43 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getIssues + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetIssuesNSID = "sh.tangled.repo.getIssues" +) + +// RepoGetIssues_Output is the output of a sh.tangled.repo.getIssues call. +type RepoGetIssues_Output struct { + Items []*RepoGetIssues_RecordView `json:"items" cborgen:"items"` +} + +// RepoGetIssues_RecordView is a "recordView" in the sh.tangled.repo.getIssues schema. +type RepoGetIssues_RecordView struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.issue record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetIssues calls the XRPC method "sh.tangled.repo.getIssues". +// +// issues: AT-URIs of the sh.tangled.repo.issue records to fetch. At most 50 per request. +func RepoGetIssues(ctx context.Context, c util.LexClient, issues []string) (*RepoGetIssues_Output, error) { + var out RepoGetIssues_Output + + params := map[string]interface{}{} + params["issues"] = issues + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getIssues", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetPull.go b/api/tangled/repogetPull.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetPull.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getPull + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetPullNSID = "sh.tangled.repo.getPull" +) + +// RepoGetPull_Output is the output of a sh.tangled.repo.getPull call. +type RepoGetPull_Output struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.pull record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetPull calls the XRPC method "sh.tangled.repo.getPull". +// +// pull: AT-URI of the sh.tangled.repo.pull record to fetch. +func RepoGetPull(ctx context.Context, c util.LexClient, pull string) (*RepoGetPull_Output, error) { + var out RepoGetPull_Output + + params := map[string]interface{}{} + params["pull"] = pull + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getPull", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetPulls.go b/api/tangled/repogetPulls.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetPulls.go @@ -0,0 +1,43 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getPulls + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetPullsNSID = "sh.tangled.repo.getPulls" +) + +// RepoGetPulls_Output is the output of a sh.tangled.repo.getPulls call. +type RepoGetPulls_Output struct { + Items []*RepoGetPulls_RecordView `json:"items" cborgen:"items"` +} + +// RepoGetPulls_RecordView is a "recordView" in the sh.tangled.repo.getPulls schema. +type RepoGetPulls_RecordView struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.pull record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetPulls calls the XRPC method "sh.tangled.repo.getPulls". +// +// pulls: AT-URIs of the sh.tangled.repo.pull records to fetch. At most 50 per request. +func RepoGetPulls(ctx context.Context, c util.LexClient, pulls []string) (*RepoGetPulls_Output, error) { + var out RepoGetPulls_Output + + params := map[string]interface{}{} + params["pulls"] = pulls + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getPulls", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetRepo.go b/api/tangled/repogetRepo.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetRepo.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getRepo + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetRepoNSID = "sh.tangled.repo.getRepo" +) + +// RepoGetRepo_Output is the output of a sh.tangled.repo.getRepo call. +type RepoGetRepo_Output struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetRepo calls the XRPC method "sh.tangled.repo.getRepo". +// +// repo: AT-URI of the sh.tangled.repo record to fetch. +func RepoGetRepo(ctx context.Context, c util.LexClient, repo string) (*RepoGetRepo_Output, error) { + var out RepoGetRepo_Output + + params := map[string]interface{}{} + params["repo"] = repo + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getRepo", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetRepoByRepoDid.go b/api/tangled/repogetRepoByRepoDid.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetRepoByRepoDid.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getRepoByRepoDid + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetRepoByRepoDidNSID = "sh.tangled.repo.getRepoByRepoDid" +) + +// RepoGetRepoByRepoDid_Output is the output of a sh.tangled.repo.getRepoByRepoDid call. +type RepoGetRepoByRepoDid_Output struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetRepoByRepoDid calls the XRPC method "sh.tangled.repo.getRepoByRepoDid". +// +// repoDid: Repo DID whose sh.tangled.repo record to fetch. +func RepoGetRepoByRepoDid(ctx context.Context, c util.LexClient, repoDid string) (*RepoGetRepoByRepoDid_Output, error) { + var out RepoGetRepoByRepoDid_Output + + params := map[string]interface{}{} + params["repoDid"] = repoDid + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getRepoByRepoDid", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repogetRepos.go b/api/tangled/repogetRepos.go new file mode 100644 --- /dev/null +++ b/api/tangled/repogetRepos.go @@ -0,0 +1,43 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.getRepos + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoGetReposNSID = "sh.tangled.repo.getRepos" +) + +// RepoGetRepos_Output is the output of a sh.tangled.repo.getRepos call. +type RepoGetRepos_Output struct { + Items []*RepoGetRepos_RecordView `json:"items" cborgen:"items"` +} + +// RepoGetRepos_RecordView is a "recordView" in the sh.tangled.repo.getRepos schema. +type RepoGetRepos_RecordView struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoGetRepos calls the XRPC method "sh.tangled.repo.getRepos". +// +// repos: AT-URIs of the sh.tangled.repo records to fetch. At most 50 per request. +func RepoGetRepos(ctx context.Context, c util.LexClient, repos []string) (*RepoGetRepos_Output, error) { + var out RepoGetRepos_Output + + params := map[string]interface{}{} + params["repos"] = repos + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getRepos", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistArtifacts.go b/api/tangled/repolistArtifacts.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistArtifacts.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listArtifacts + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListArtifactsNSID = "sh.tangled.repo.listArtifacts" +) + +// RepoListArtifacts_ListItem is a "listItem" in the sh.tangled.repo.listArtifacts schema. +type RepoListArtifacts_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.artifact record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoListArtifacts_Output is the output of a sh.tangled.repo.listArtifacts call. +type RepoListArtifacts_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListArtifacts_ListItem `json:"items" cborgen:"items"` +} + +// RepoListArtifacts calls the XRPC method "sh.tangled.repo.listArtifacts". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Repo or release identifier whose artifacts to list. +func RepoListArtifacts(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoListArtifacts_Output, error) { + var out RepoListArtifacts_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listArtifacts", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistArtifactsBy.go b/api/tangled/repolistArtifactsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistArtifactsBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listArtifactsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListArtifactsByNSID = "sh.tangled.repo.listArtifactsBy" +) + +// RepoListArtifactsBy_Output is the output of a sh.tangled.repo.listArtifactsBy call. +type RepoListArtifactsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListArtifacts_ListItem `json:"items" cborgen:"items"` +} + +// RepoListArtifactsBy calls the XRPC method "sh.tangled.repo.listArtifactsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose artifact authorings to list. +func RepoListArtifactsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoListArtifactsBy_Output, error) { + var out RepoListArtifactsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listArtifactsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistIssues.go b/api/tangled/repolistIssues.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistIssues.go @@ -0,0 +1,69 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listIssues + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListIssuesNSID = "sh.tangled.repo.listIssues" +) + +// RepoListIssues_IssueListItem is a "issueListItem" in the sh.tangled.repo.listIssues schema. +type RepoListIssues_IssueListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + // commentCount: Count of sh.tangled.repo.issue.comment records targeting this issue. + CommentCount int64 `json:"commentCount" cborgen:"commentCount"` + // state: Latest derived state. + State string `json:"state" cborgen:"state"` + // stateUpdatedAt: TID-derived timestamp of the latest state record. + StateUpdatedAt *string `json:"stateUpdatedAt,omitempty" cborgen:"stateUpdatedAt,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.issue record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoListIssues_Output is the output of a sh.tangled.repo.listIssues call. +type RepoListIssues_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListIssues_IssueListItem `json:"items" cborgen:"items"` +} + +// RepoListIssues calls the XRPC method "sh.tangled.repo.listIssues". +// +// author: Restrict to issues authored by this user DID. +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// state: Restrict to issues whose latest derived state matches. +// subject: Repo DID to list issues for +func RepoListIssues(ctx context.Context, c util.LexClient, author string, cursor string, limit int64, order string, state string, subject string) (*RepoListIssues_Output, error) { + var out RepoListIssues_Output + + params := map[string]interface{}{} + if author != "" { + params["author"] = author + } + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + if state != "" { + params["state"] = state + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listIssues", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistIssuesBy.go b/api/tangled/repolistIssuesBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistIssuesBy.go @@ -0,0 +1,51 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listIssuesBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListIssuesByNSID = "sh.tangled.repo.listIssuesBy" +) + +// RepoListIssuesBy_Output is the output of a sh.tangled.repo.listIssuesBy call. +type RepoListIssuesBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListIssues_IssueListItem `json:"items" cborgen:"items"` +} + +// RepoListIssuesBy calls the XRPC method "sh.tangled.repo.listIssuesBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// state: Restrict to issues whose latest derived state matches. +// subject: Actor DID whose issue authorings to list +func RepoListIssuesBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, state string, subject string) (*RepoListIssuesBy_Output, error) { + var out RepoListIssuesBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + if state != "" { + params["state"] = state + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listIssuesBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistPulls.go b/api/tangled/repolistPulls.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistPulls.go @@ -0,0 +1,69 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listPulls + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListPullsNSID = "sh.tangled.repo.listPulls" +) + +// RepoListPulls_Output is the output of a sh.tangled.repo.listPulls call. +type RepoListPulls_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListPulls_PullListItem `json:"items" cborgen:"items"` +} + +// RepoListPulls_PullListItem is a "pullListItem" in the sh.tangled.repo.listPulls schema. +type RepoListPulls_PullListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + // commentCount: Count of sh.tangled.repo.pull.comment records targeting this pull. + CommentCount int64 `json:"commentCount" cborgen:"commentCount"` + // state: Latest derived state. + State string `json:"state" cborgen:"state"` + // stateUpdatedAt: TID-derived timestamp of the latest pull status record. + StateUpdatedAt *string `json:"stateUpdatedAt,omitempty" cborgen:"stateUpdatedAt,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo.pull record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoListPulls calls the XRPC method "sh.tangled.repo.listPulls". +// +// author: Restrict to pulls authored by this user DID. +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// status: Restrict to pulls whose latest derived status matches. +// subject: Repo DID to list pulls for +func RepoListPulls(ctx context.Context, c util.LexClient, author string, cursor string, limit int64, order string, status string, subject string) (*RepoListPulls_Output, error) { + var out RepoListPulls_Output + + params := map[string]interface{}{} + if author != "" { + params["author"] = author + } + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + if status != "" { + params["status"] = status + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listPulls", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistPullsBy.go b/api/tangled/repolistPullsBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistPullsBy.go @@ -0,0 +1,51 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listPullsBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListPullsByNSID = "sh.tangled.repo.listPullsBy" +) + +// RepoListPullsBy_Output is the output of a sh.tangled.repo.listPullsBy call. +type RepoListPullsBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListPulls_PullListItem `json:"items" cborgen:"items"` +} + +// RepoListPullsBy calls the XRPC method "sh.tangled.repo.listPullsBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// status: Restrict to pulls whose latest derived status matches. +// subject: Actor DID whose pull authorings to list +func RepoListPullsBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, status string, subject string) (*RepoListPullsBy_Output, error) { + var out RepoListPullsBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + if status != "" { + params["status"] = status + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listPullsBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/repolistRepos.go b/api/tangled/repolistRepos.go new file mode 100644 --- /dev/null +++ b/api/tangled/repolistRepos.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.repo.listRepos + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + RepoListReposNSID = "sh.tangled.repo.listRepos" +) + +// RepoListRepos_ListItem is a "listItem" in the sh.tangled.repo.listRepos schema. +type RepoListRepos_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.repo record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// RepoListRepos_Output is the output of a sh.tangled.repo.listRepos call. +type RepoListRepos_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*RepoListRepos_ListItem `json:"items" cborgen:"items"` +} + +// RepoListRepos calls the XRPC method "sh.tangled.repo.listRepos". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Owner DID whose repo records to list. +func RepoListRepos(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*RepoListRepos_Output, error) { + var out RepoListRepos_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listRepos", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/searchquery.go b/api/tangled/searchquery.go new file mode 100644 --- /dev/null +++ b/api/tangled/searchquery.go @@ -0,0 +1,75 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.search.query + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SearchQueryNSID = "sh.tangled.search.query" +) + +// SearchQuery_Hit is a "hit" in the sh.tangled.search.query schema. +type SearchQuery_Hit struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + // nsid: Collection of the matched record. + Nsid string `json:"nsid" cborgen:"nsid"` + // score: Relevance score of the hit, a floating-point number where higher ranks first. + Score *util.LexiconTypeDecoder `json:"score" cborgen:"score"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded matched record. + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// SearchQuery_Output is the output of a sh.tangled.search.query call. +type SearchQuery_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Hits []*SearchQuery_Hit `json:"hits" cborgen:"hits"` +} + +// SearchQuery calls the XRPC method "sh.tangled.search.query". +// +// author: Restrict to records authored by this DID. +// cursor: Pagination cursor +// nsid: Restrict to records of this collection. +// q: Full-text search query. +// repo: Restrict to records under this repo DID. +// since: Restrict to records created at or after this time. +// until: Restrict to records created at or before this time. +func SearchQuery(ctx context.Context, c util.LexClient, author string, cursor string, limit int64, nsid string, q string, repo string, since string, until string) (*SearchQuery_Output, error) { + var out SearchQuery_Output + + params := map[string]interface{}{} + if author != "" { + params["author"] = author + } + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if nsid != "" { + params["nsid"] = nsid + } + params["q"] = q + if repo != "" { + params["repo"] = repo + } + if since != "" { + params["since"] = since + } + if until != "" { + params["until"] = until + } + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.search.query", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/spindlecountMembers.go b/api/tangled/spindlecountMembers.go new file mode 100644 --- /dev/null +++ b/api/tangled/spindlecountMembers.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.spindle.countMembers + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SpindleCountMembersNSID = "sh.tangled.spindle.countMembers" +) + +// SpindleCountMembers_Output is the output of a sh.tangled.spindle.countMembers call. +type SpindleCountMembers_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// SpindleCountMembers calls the XRPC method "sh.tangled.spindle.countMembers". +// +// subject: Spindle identifier whose member records to list. +func SpindleCountMembers(ctx context.Context, c util.LexClient, subject string) (*SpindleCountMembers_Output, error) { + var out SpindleCountMembers_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.spindle.countMembers", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/spindlecountMembersBy.go b/api/tangled/spindlecountMembersBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/spindlecountMembersBy.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.spindle.countMembersBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SpindleCountMembersByNSID = "sh.tangled.spindle.countMembersBy" +) + +// SpindleCountMembersBy_Output is the output of a sh.tangled.spindle.countMembersBy call. +type SpindleCountMembersBy_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// SpindleCountMembersBy calls the XRPC method "sh.tangled.spindle.countMembersBy". +// +// subject: Actor DID whose spindle-member authorings to list. +func SpindleCountMembersBy(ctx context.Context, c util.LexClient, subject string) (*SpindleCountMembersBy_Output, error) { + var out SpindleCountMembersBy_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.spindle.countMembersBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/spindlecountSpindles.go b/api/tangled/spindlecountSpindles.go new file mode 100644 --- /dev/null +++ b/api/tangled/spindlecountSpindles.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.spindle.countSpindles + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SpindleCountSpindlesNSID = "sh.tangled.spindle.countSpindles" +) + +// SpindleCountSpindles_Output is the output of a sh.tangled.spindle.countSpindles call. +type SpindleCountSpindles_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// SpindleCountSpindles calls the XRPC method "sh.tangled.spindle.countSpindles". +// +// subject: Owner DID whose spindle records to list. +func SpindleCountSpindles(ctx context.Context, c util.LexClient, subject string) (*SpindleCountSpindles_Output, error) { + var out SpindleCountSpindles_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.spindle.countSpindles", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/spindlelistMembers.go b/api/tangled/spindlelistMembers.go new file mode 100644 --- /dev/null +++ b/api/tangled/spindlelistMembers.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.spindle.listMembers + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SpindleListMembersNSID = "sh.tangled.spindle.listMembers" +) + +// SpindleListMembers_ListItem is a "listItem" in the sh.tangled.spindle.listMembers schema. +type SpindleListMembers_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.spindle.member record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// SpindleListMembers_Output is the output of a sh.tangled.spindle.listMembers call. +type SpindleListMembers_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*SpindleListMembers_ListItem `json:"items" cborgen:"items"` +} + +// SpindleListMembers calls the XRPC method "sh.tangled.spindle.listMembers". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Spindle identifier whose member records to list. +func SpindleListMembers(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*SpindleListMembers_Output, error) { + var out SpindleListMembers_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.spindle.listMembers", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/spindlelistMembersBy.go b/api/tangled/spindlelistMembersBy.go new file mode 100644 --- /dev/null +++ b/api/tangled/spindlelistMembersBy.go @@ -0,0 +1,47 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.spindle.listMembersBy + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SpindleListMembersByNSID = "sh.tangled.spindle.listMembersBy" +) + +// SpindleListMembersBy_Output is the output of a sh.tangled.spindle.listMembersBy call. +type SpindleListMembersBy_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*SpindleListMembers_ListItem `json:"items" cborgen:"items"` +} + +// SpindleListMembersBy calls the XRPC method "sh.tangled.spindle.listMembersBy". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Actor DID whose spindle-member authorings to list. +func SpindleListMembersBy(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*SpindleListMembersBy_Output, error) { + var out SpindleListMembersBy_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.spindle.listMembersBy", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/spindlelistSpindles.go b/api/tangled/spindlelistSpindles.go new file mode 100644 --- /dev/null +++ b/api/tangled/spindlelistSpindles.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.spindle.listSpindles + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + SpindleListSpindlesNSID = "sh.tangled.spindle.listSpindles" +) + +// SpindleListSpindles_ListItem is a "listItem" in the sh.tangled.spindle.listSpindles schema. +type SpindleListSpindles_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.spindle record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// SpindleListSpindles_Output is the output of a sh.tangled.spindle.listSpindles call. +type SpindleListSpindles_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*SpindleListSpindles_ListItem `json:"items" cborgen:"items"` +} + +// SpindleListSpindles calls the XRPC method "sh.tangled.spindle.listSpindles". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Owner DID whose spindle records to list. +func SpindleListSpindles(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*SpindleListSpindles_Output, error) { + var out SpindleListSpindles_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.spindle.listSpindles", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/stringcountStrings.go b/api/tangled/stringcountStrings.go new file mode 100644 --- /dev/null +++ b/api/tangled/stringcountStrings.go @@ -0,0 +1,38 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.string.countStrings + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + StringCountStringsNSID = "sh.tangled.string.countStrings" +) + +// StringCountStrings_Output is the output of a sh.tangled.string.countStrings call. +type StringCountStrings_Output struct { + // count: Total number of matching records. + Count int64 `json:"count" cborgen:"count"` + // distinctAuthors: Number of distinct authors among the matching records. + DistinctAuthors int64 `json:"distinctAuthors" cborgen:"distinctAuthors"` +} + +// StringCountStrings calls the XRPC method "sh.tangled.string.countStrings". +// +// subject: Scope identifier whose string records to list. +func StringCountStrings(ctx context.Context, c util.LexClient, subject string) (*StringCountStrings_Output, error) { + var out StringCountStrings_Output + + params := map[string]interface{}{} + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.string.countStrings", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/tangled/stringlistStrings.go b/api/tangled/stringlistStrings.go new file mode 100644 --- /dev/null +++ b/api/tangled/stringlistStrings.go @@ -0,0 +1,55 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package tangled + +// schema: sh.tangled.string.listStrings + +import ( + "context" + + "github.com/bluesky-social/indigo/lex/util" +) + +const ( + StringListStringsNSID = "sh.tangled.string.listStrings" +) + +// StringListStrings_ListItem is a "listItem" in the sh.tangled.string.listStrings schema. +type StringListStrings_ListItem struct { + Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"` + Uri string `json:"uri" cborgen:"uri"` + // value: Embedded sh.tangled.string record + Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"` +} + +// StringListStrings_Output is the output of a sh.tangled.string.listStrings call. +type StringListStrings_Output struct { + Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"` + Items []*StringListStrings_ListItem `json:"items" cborgen:"items"` +} + +// StringListStrings calls the XRPC method "sh.tangled.string.listStrings". +// +// cursor: Pagination cursor +// order: Sort direction by createdAt. +// subject: Scope identifier whose string records to list. +func StringListStrings(ctx context.Context, c util.LexClient, cursor string, limit int64, order string, subject string) (*StringListStrings_Output, error) { + var out StringListStrings_Output + + params := map[string]interface{}{} + if cursor != "" { + params["cursor"] = cursor + } + if limit != 0 { + params["limit"] = limit + } + if order != "" { + params["order"] = order + } + params["subject"] = subject + if err := c.LexDo(ctx, util.Query, "", "sh.tangled.string.listStrings", params, nil, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/bobbin/containerfiles/bobbin.Containerfile b/bobbin/containerfiles/bobbin.Containerfile --- a/bobbin/containerfiles/bobbin.Containerfile +++ b/bobbin/containerfiles/bobbin.Containerfile @@ -8,6 +8,7 @@ WORKDIR /src COPY Cargo.toml Cargo.lock rust-toolchain.toml ./ COPY lexicons ./lexicons COPY bobbin ./bobbin +COPY shuttle ./shuttle RUN cargo build --profile ${BOBBIN_PROFILE} --bin bobbin --package bobbin RUN if [ "${BOBBIN_PROFILE}" = "release" ]; then strip target/${BOBBIN_PROFILE}/bobbin; fi diff --git a/bobbin/crates/types/build.rs b/bobbin/crates/types/build.rs --- a/bobbin/crates/types/build.rs +++ b/bobbin/crates/types/build.rs @@ -22,11 +22,9 @@ let lexicons_dir = std::env::var("BOBBIN_LEXICONS_DIR") .map(PathBuf::from) .unwrap_or_else(|_| workspace_root.join(DEFAULT_LEXICONS_SUBDIR)); - let additions_dir = manifest_dir.join(DEFAULT_LEXICONS_SUBDIR); println!("cargo:rerun-if-env-changed=BOBBIN_LEXICONS_DIR"); println!("cargo:rerun-if-changed={}", lexicons_dir.display()); - println!("cargo:rerun-if-changed={}", additions_dir.display()); println!("cargo:rerun-if-changed=build.rs"); let out_dir = PathBuf::from(std::env::var("OUT_DIR")?); @@ -36,7 +34,6 @@ if staged.exists() { std::fs::remove_dir_all(&staged).context("clean staged lexicons")?; } stage_lexicons(&lexicons_dir, &staged)?; - stage_lexicons(&additions_dir, &staged)?; let corpus = LexiconCorpus::load_from_dir(&staged) .map_err(|e| anyhow::anyhow!("load lexicon corpus: {e:?}"))?; diff --git a/bobbin/crates/types/lexicons/feed/listComments.json b/lexicons/feed/listComments.json rename from bobbin/crates/types/lexicons/feed/listComments.json rename to lexicons/feed/listComments.json --- a/bobbin/crates/types/lexicons/feed/listComments.json +++ b/lexicons/feed/listComments.json @@ -11,7 +11,7 @@ "properties": { "subject": { "type": "string", "format": "at-uri", - "description": "Record AT-URI the comments are attached to." + "description": "Record AT-URI the comments attach to." }, "cursor": { "type": "string", diff --git a/bobbin/crates/types/lexicons/feed/listCommentsBy.json b/lexicons/feed/listCommentsBy.json rename from bobbin/crates/types/lexicons/feed/listCommentsBy.json rename to lexicons/feed/listCommentsBy.json --- a/bobbin/crates/types/lexicons/feed/listCommentsBy.json +++ b/lexicons/feed/listCommentsBy.json diff --git a/bobbin/crates/types/lexicons/feed/listReactions.json b/lexicons/feed/listReactions.json rename from bobbin/crates/types/lexicons/feed/listReactions.json rename to lexicons/feed/listReactions.json --- a/bobbin/crates/types/lexicons/feed/listReactions.json +++ b/lexicons/feed/listReactions.json diff --git a/bobbin/crates/types/lexicons/feed/listReactionsBy.json b/lexicons/feed/listReactionsBy.json rename from bobbin/crates/types/lexicons/feed/listReactionsBy.json rename to lexicons/feed/listReactionsBy.json --- a/bobbin/crates/types/lexicons/feed/listReactionsBy.json +++ b/lexicons/feed/listReactionsBy.json diff --git a/bobbin/crates/types/lexicons/feed/listStars.json b/lexicons/feed/listStars.json rename from bobbin/crates/types/lexicons/feed/listStars.json rename to lexicons/feed/listStars.json --- a/bobbin/crates/types/lexicons/feed/listStars.json +++ b/lexicons/feed/listStars.json diff --git a/bobbin/crates/types/lexicons/feed/listStarsBy.json b/lexicons/feed/listStarsBy.json rename from bobbin/crates/types/lexicons/feed/listStarsBy.json rename to lexicons/feed/listStarsBy.json --- a/bobbin/crates/types/lexicons/feed/listStarsBy.json +++ b/lexicons/feed/listStarsBy.json diff --git a/bobbin/crates/types/lexicons/git/listRefUpdates.json b/lexicons/git/listRefUpdates.json rename from bobbin/crates/types/lexicons/git/listRefUpdates.json rename to lexicons/git/listRefUpdates.json --- a/bobbin/crates/types/lexicons/git/listRefUpdates.json +++ b/lexicons/git/listRefUpdates.json diff --git a/bobbin/crates/types/lexicons/git/listRefUpdatesBy.json b/lexicons/git/listRefUpdatesBy.json rename from bobbin/crates/types/lexicons/git/listRefUpdatesBy.json rename to lexicons/git/listRefUpdatesBy.json --- a/bobbin/crates/types/lexicons/git/listRefUpdatesBy.json +++ b/lexicons/git/listRefUpdatesBy.json diff --git a/bobbin/crates/types/lexicons/graph/listFollows.json b/lexicons/graph/listFollows.json rename from bobbin/crates/types/lexicons/graph/listFollows.json rename to lexicons/graph/listFollows.json --- a/bobbin/crates/types/lexicons/graph/listFollows.json +++ b/lexicons/graph/listFollows.json diff --git a/bobbin/crates/types/lexicons/graph/listFollowsBy.json b/lexicons/graph/listFollowsBy.json rename from bobbin/crates/types/lexicons/graph/listFollowsBy.json rename to lexicons/graph/listFollowsBy.json --- a/bobbin/crates/types/lexicons/graph/listFollowsBy.json +++ b/lexicons/graph/listFollowsBy.json diff --git a/bobbin/crates/types/lexicons/graph/listVouches.json b/lexicons/graph/listVouches.json rename from bobbin/crates/types/lexicons/graph/listVouches.json rename to lexicons/graph/listVouches.json --- a/bobbin/crates/types/lexicons/graph/listVouches.json +++ b/lexicons/graph/listVouches.json diff --git a/bobbin/crates/types/lexicons/graph/listVouchesBy.json b/lexicons/graph/listVouchesBy.json rename from bobbin/crates/types/lexicons/graph/listVouchesBy.json rename to lexicons/graph/listVouchesBy.json --- a/bobbin/crates/types/lexicons/graph/listVouchesBy.json +++ b/lexicons/graph/listVouchesBy.json diff --git a/bobbin/crates/types/lexicons/knot/listKnots.json b/lexicons/knot/listKnots.json rename from bobbin/crates/types/lexicons/knot/listKnots.json rename to lexicons/knot/listKnots.json --- a/bobbin/crates/types/lexicons/knot/listKnots.json +++ b/lexicons/knot/listKnots.json diff --git a/bobbin/crates/types/lexicons/label/listDefinitions.json b/lexicons/label/listDefinitions.json rename from bobbin/crates/types/lexicons/label/listDefinitions.json rename to lexicons/label/listDefinitions.json --- a/bobbin/crates/types/lexicons/label/listDefinitions.json +++ b/lexicons/label/listDefinitions.json diff --git a/bobbin/crates/types/lexicons/label/listOps.json b/lexicons/label/listOps.json rename from bobbin/crates/types/lexicons/label/listOps.json rename to lexicons/label/listOps.json --- a/bobbin/crates/types/lexicons/label/listOps.json +++ b/lexicons/label/listOps.json diff --git a/bobbin/crates/types/lexicons/label/listOpsBy.json b/lexicons/label/listOpsBy.json rename from bobbin/crates/types/lexicons/label/listOpsBy.json rename to lexicons/label/listOpsBy.json --- a/bobbin/crates/types/lexicons/label/listOpsBy.json +++ b/lexicons/label/listOpsBy.json diff --git a/bobbin/crates/types/lexicons/pipeline/listPipelines.json b/lexicons/pipeline/listPipelines.json rename from bobbin/crates/types/lexicons/pipeline/listPipelines.json rename to lexicons/pipeline/listPipelines.json --- a/bobbin/crates/types/lexicons/pipeline/listPipelines.json +++ b/lexicons/pipeline/listPipelines.json diff --git a/bobbin/crates/types/lexicons/pipeline/listPipelinesBy.json b/lexicons/pipeline/listPipelinesBy.json rename from bobbin/crates/types/lexicons/pipeline/listPipelinesBy.json rename to lexicons/pipeline/listPipelinesBy.json --- a/bobbin/crates/types/lexicons/pipeline/listPipelinesBy.json +++ b/lexicons/pipeline/listPipelinesBy.json diff --git a/bobbin/crates/types/lexicons/pipeline/listStatuses.json b/lexicons/pipeline/listStatuses.json rename from bobbin/crates/types/lexicons/pipeline/listStatuses.json rename to lexicons/pipeline/listStatuses.json --- a/bobbin/crates/types/lexicons/pipeline/listStatuses.json +++ b/lexicons/pipeline/listStatuses.json diff --git a/bobbin/crates/types/lexicons/pipeline/listStatusesBy.json b/lexicons/pipeline/listStatusesBy.json rename from bobbin/crates/types/lexicons/pipeline/listStatusesBy.json rename to lexicons/pipeline/listStatusesBy.json --- a/bobbin/crates/types/lexicons/pipeline/listStatusesBy.json +++ b/lexicons/pipeline/listStatusesBy.json diff --git a/bobbin/crates/types/lexicons/publicKey/listKeys.json b/lexicons/publicKey/listKeys.json rename from bobbin/crates/types/lexicons/publicKey/listKeys.json rename to lexicons/publicKey/listKeys.json --- a/bobbin/crates/types/lexicons/publicKey/listKeys.json +++ b/lexicons/publicKey/listKeys.json diff --git a/bobbin/crates/types/lexicons/repo/issue/listStates.json b/lexicons/repo/issue/listStates.json rename from bobbin/crates/types/lexicons/repo/issue/listStates.json rename to lexicons/repo/issue/listStates.json --- a/bobbin/crates/types/lexicons/repo/issue/listStates.json +++ b/lexicons/repo/issue/listStates.json diff --git a/bobbin/crates/types/lexicons/repo/issue/listStatesBy.json b/lexicons/repo/issue/listStatesBy.json rename from bobbin/crates/types/lexicons/repo/issue/listStatesBy.json rename to lexicons/repo/issue/listStatesBy.json --- a/bobbin/crates/types/lexicons/repo/issue/listStatesBy.json +++ b/lexicons/repo/issue/listStatesBy.json diff --git a/bobbin/crates/types/lexicons/repo/listArtifacts.json b/lexicons/repo/listArtifacts.json rename from bobbin/crates/types/lexicons/repo/listArtifacts.json rename to lexicons/repo/listArtifacts.json --- a/bobbin/crates/types/lexicons/repo/listArtifacts.json +++ b/lexicons/repo/listArtifacts.json diff --git a/bobbin/crates/types/lexicons/repo/listArtifactsBy.json b/lexicons/repo/listArtifactsBy.json rename from bobbin/crates/types/lexicons/repo/listArtifactsBy.json rename to lexicons/repo/listArtifactsBy.json --- a/bobbin/crates/types/lexicons/repo/listArtifactsBy.json +++ b/lexicons/repo/listArtifactsBy.json diff --git a/bobbin/crates/types/lexicons/repo/listIssues.json b/lexicons/repo/listIssues.json rename from bobbin/crates/types/lexicons/repo/listIssues.json rename to lexicons/repo/listIssues.json --- a/bobbin/crates/types/lexicons/repo/listIssues.json +++ b/lexicons/repo/listIssues.json diff --git a/bobbin/crates/types/lexicons/repo/listIssuesBy.json b/lexicons/repo/listIssuesBy.json rename from bobbin/crates/types/lexicons/repo/listIssuesBy.json rename to lexicons/repo/listIssuesBy.json --- a/bobbin/crates/types/lexicons/repo/listIssuesBy.json +++ b/lexicons/repo/listIssuesBy.json diff --git a/bobbin/crates/types/lexicons/repo/listPulls.json b/lexicons/repo/listPulls.json rename from bobbin/crates/types/lexicons/repo/listPulls.json rename to lexicons/repo/listPulls.json --- a/bobbin/crates/types/lexicons/repo/listPulls.json +++ b/lexicons/repo/listPulls.json diff --git a/bobbin/crates/types/lexicons/repo/listPullsBy.json b/lexicons/repo/listPullsBy.json rename from bobbin/crates/types/lexicons/repo/listPullsBy.json rename to lexicons/repo/listPullsBy.json --- a/bobbin/crates/types/lexicons/repo/listPullsBy.json +++ b/lexicons/repo/listPullsBy.json diff --git a/bobbin/crates/types/lexicons/repo/listRepos.json b/lexicons/repo/listRepos.json rename from bobbin/crates/types/lexicons/repo/listRepos.json rename to lexicons/repo/listRepos.json --- a/bobbin/crates/types/lexicons/repo/listRepos.json +++ b/lexicons/repo/listRepos.json diff --git a/bobbin/crates/types/lexicons/repo/pull/listStatuses.json b/lexicons/repo/pull/listStatuses.json rename from bobbin/crates/types/lexicons/repo/pull/listStatuses.json rename to lexicons/repo/pull/listStatuses.json --- a/bobbin/crates/types/lexicons/repo/pull/listStatuses.json +++ b/lexicons/repo/pull/listStatuses.json diff --git a/bobbin/crates/types/lexicons/repo/pull/listStatusesBy.json b/lexicons/repo/pull/listStatusesBy.json rename from bobbin/crates/types/lexicons/repo/pull/listStatusesBy.json rename to lexicons/repo/pull/listStatusesBy.json --- a/bobbin/crates/types/lexicons/repo/pull/listStatusesBy.json +++ b/lexicons/repo/pull/listStatusesBy.json diff --git a/bobbin/crates/types/lexicons/spindle/listMembers.json b/lexicons/spindle/listMembers.json rename from bobbin/crates/types/lexicons/spindle/listMembers.json rename to lexicons/spindle/listMembers.json --- a/bobbin/crates/types/lexicons/spindle/listMembers.json +++ b/lexicons/spindle/listMembers.json diff --git a/bobbin/crates/types/lexicons/spindle/listMembersBy.json b/lexicons/spindle/listMembersBy.json rename from bobbin/crates/types/lexicons/spindle/listMembersBy.json rename to lexicons/spindle/listMembersBy.json --- a/bobbin/crates/types/lexicons/spindle/listMembersBy.json +++ b/lexicons/spindle/listMembersBy.json diff --git a/bobbin/crates/types/lexicons/spindle/listSpindles.json b/lexicons/spindle/listSpindles.json rename from bobbin/crates/types/lexicons/spindle/listSpindles.json rename to lexicons/spindle/listSpindles.json --- a/bobbin/crates/types/lexicons/spindle/listSpindles.json +++ b/lexicons/spindle/listSpindles.json diff --git a/bobbin/crates/types/lexicons/string/listStrings.json b/lexicons/string/listStrings.json rename from bobbin/crates/types/lexicons/string/listStrings.json rename to lexicons/string/listStrings.json --- a/bobbin/crates/types/lexicons/string/listStrings.json +++ b/lexicons/string/listStrings.json diff --git a/lexicons/actor/getProfile.json b/lexicons/actor/getProfile.json new file mode 100644 --- /dev/null +++ b/lexicons/actor/getProfile.json @@ -0,0 +1,41 @@ +{ + "lexicon": 1, + "id": "sh.tangled.actor.getProfile", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["actor"], + "properties": { + "actor": { + "type": "string", + "format": "at-uri", + "description": "AT-URI of the sh.tangled.actor.profile record to fetch." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.actor.profile record." + } + } + } + } + } + } +} diff --git a/lexicons/actor/getProfiles.json b/lexicons/actor/getProfiles.json new file mode 100644 --- /dev/null +++ b/lexicons/actor/getProfiles.json @@ -0,0 +1,58 @@ +{ + "lexicon": 1, + "id": "sh.tangled.actor.getProfiles", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["actors"], + "properties": { + "actors": { + "type": "array", + "items": { + "type": "string", + "format": "at-uri" + }, + "maxLength": 50, + "description": "AT-URIs of the sh.tangled.actor.profile records to fetch. At most 50 per request." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["items"], + "properties": { + "items": { + "type": "array", + "items": { + "type": "ref", + "ref": "#recordView" + } + } + } + } + } + }, + "recordView": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.actor.profile record." + } + } + } + } +} diff --git a/lexicons/feed/countComments.json b/lexicons/feed/countComments.json new file mode 100644 --- /dev/null +++ b/lexicons/feed/countComments.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.feed.countComments", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "at-uri", + "description": "Record AT-URI the comments attach to." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/feed/countCommentsBy.json b/lexicons/feed/countCommentsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/feed/countCommentsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.feed.countCommentsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose comment authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/feed/countReactions.json b/lexicons/feed/countReactions.json new file mode 100644 --- /dev/null +++ b/lexicons/feed/countReactions.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.feed.countReactions", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "at-uri", + "description": "Record AT-URI the reactions target." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/feed/countReactionsBy.json b/lexicons/feed/countReactionsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/feed/countReactionsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.feed.countReactionsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose reaction authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/feed/countStars.json b/lexicons/feed/countStars.json new file mode 100644 --- /dev/null +++ b/lexicons/feed/countStars.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.feed.countStars", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Repo DID to list star edges for." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/feed/countStarsBy.json b/lexicons/feed/countStarsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/feed/countStarsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.feed.countStarsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose star authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/git/countRefUpdates.json b/lexicons/git/countRefUpdates.json new file mode 100644 --- /dev/null +++ b/lexicons/git/countRefUpdates.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.git.countRefUpdates", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Repo DID whose ref-update records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/git/countRefUpdatesBy.json b/lexicons/git/countRefUpdatesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/git/countRefUpdatesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.git.countRefUpdatesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose ref-update authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/graph/countFollows.json b/lexicons/graph/countFollows.json new file mode 100644 --- /dev/null +++ b/lexicons/graph/countFollows.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.graph.countFollows", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Followee DID whose inbound follows to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/graph/countFollowsBy.json b/lexicons/graph/countFollowsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/graph/countFollowsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.graph.countFollowsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose follow authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/graph/countVouches.json b/lexicons/graph/countVouches.json new file mode 100644 --- /dev/null +++ b/lexicons/graph/countVouches.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.graph.countVouches", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Vouchee DID whose inbound vouches to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/graph/countVouchesBy.json b/lexicons/graph/countVouchesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/graph/countVouchesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.graph.countVouchesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose vouch authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/knot/countKnots.json b/lexicons/knot/countKnots.json new file mode 100644 --- /dev/null +++ b/lexicons/knot/countKnots.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.knot.countKnots", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Owner DID whose knot records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/knot/countMembers.json b/lexicons/knot/countMembers.json new file mode 100644 --- /dev/null +++ b/lexicons/knot/countMembers.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.knot.countMembers", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Knot identifier whose member records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/knot/countMembersBy.json b/lexicons/knot/countMembersBy.json new file mode 100644 --- /dev/null +++ b/lexicons/knot/countMembersBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.knot.countMembersBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose knot-member authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/label/countDefinitions.json b/lexicons/label/countDefinitions.json new file mode 100644 --- /dev/null +++ b/lexicons/label/countDefinitions.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.label.countDefinitions", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Scope identifier whose label definitions to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/label/countOps.json b/lexicons/label/countOps.json new file mode 100644 --- /dev/null +++ b/lexicons/label/countOps.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.label.countOps", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Scope identifier whose label op records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/label/countOpsBy.json b/lexicons/label/countOpsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/label/countOpsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.label.countOpsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose label-op authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/pipeline/countPipelines.json b/lexicons/pipeline/countPipelines.json new file mode 100644 --- /dev/null +++ b/lexicons/pipeline/countPipelines.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.pipeline.countPipelines", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Repo or spindle identifier whose pipeline records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/pipeline/countPipelinesBy.json b/lexicons/pipeline/countPipelinesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/pipeline/countPipelinesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.pipeline.countPipelinesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose pipeline authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/pipeline/countStatuses.json b/lexicons/pipeline/countStatuses.json new file mode 100644 --- /dev/null +++ b/lexicons/pipeline/countStatuses.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.pipeline.countStatuses", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "at-uri", + "description": "Pipeline AT-URI whose status records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/pipeline/countStatusesBy.json b/lexicons/pipeline/countStatusesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/pipeline/countStatusesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.pipeline.countStatusesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose pipeline-status authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/publicKey/countKeys.json b/lexicons/publicKey/countKeys.json new file mode 100644 --- /dev/null +++ b/lexicons/publicKey/countKeys.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.publicKey.countKeys", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Owner DID whose public-key records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countArtifacts.json b/lexicons/repo/countArtifacts.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countArtifacts.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countArtifacts", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Repo or release identifier whose artifacts to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countArtifactsBy.json b/lexicons/repo/countArtifactsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countArtifactsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countArtifactsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose artifact authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countCollaborators.json b/lexicons/repo/countCollaborators.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countCollaborators.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countCollaborators", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Repo DID whose collaborator records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countCollaboratorsBy.json b/lexicons/repo/countCollaboratorsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countCollaboratorsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countCollaboratorsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose collaborator authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countIssues.json b/lexicons/repo/countIssues.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countIssues.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countIssues", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Repo DID to list issues for" + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countIssuesBy.json b/lexicons/repo/countIssuesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countIssuesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countIssuesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose issue authorings to list" + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countPulls.json b/lexicons/repo/countPulls.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countPulls.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countPulls", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Repo DID to list pulls for" + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countPullsBy.json b/lexicons/repo/countPullsBy.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countPullsBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countPullsBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose pull authorings to list" + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/countRepos.json b/lexicons/repo/countRepos.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/countRepos.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.countRepos", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Owner DID whose repo records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/getIssue.json b/lexicons/repo/getIssue.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getIssue.json @@ -0,0 +1,41 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getIssue", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["issue"], + "properties": { + "issue": { + "type": "string", + "format": "at-uri", + "description": "AT-URI of the sh.tangled.repo.issue record to fetch." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo.issue record." + } + } + } + } + } + } +} diff --git a/lexicons/repo/getIssues.json b/lexicons/repo/getIssues.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getIssues.json @@ -0,0 +1,58 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getIssues", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["issues"], + "properties": { + "issues": { + "type": "array", + "items": { + "type": "string", + "format": "at-uri" + }, + "maxLength": 50, + "description": "AT-URIs of the sh.tangled.repo.issue records to fetch. At most 50 per request." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["items"], + "properties": { + "items": { + "type": "array", + "items": { + "type": "ref", + "ref": "#recordView" + } + } + } + } + } + }, + "recordView": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo.issue record." + } + } + } + } +} diff --git a/lexicons/repo/getPull.json b/lexicons/repo/getPull.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getPull.json @@ -0,0 +1,41 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getPull", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["pull"], + "properties": { + "pull": { + "type": "string", + "format": "at-uri", + "description": "AT-URI of the sh.tangled.repo.pull record to fetch." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo.pull record." + } + } + } + } + } + } +} diff --git a/lexicons/repo/getPulls.json b/lexicons/repo/getPulls.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getPulls.json @@ -0,0 +1,58 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getPulls", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["pulls"], + "properties": { + "pulls": { + "type": "array", + "items": { + "type": "string", + "format": "at-uri" + }, + "maxLength": 50, + "description": "AT-URIs of the sh.tangled.repo.pull records to fetch. At most 50 per request." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["items"], + "properties": { + "items": { + "type": "array", + "items": { + "type": "ref", + "ref": "#recordView" + } + } + } + } + } + }, + "recordView": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo.pull record." + } + } + } + } +} diff --git a/lexicons/repo/getRepo.json b/lexicons/repo/getRepo.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getRepo.json @@ -0,0 +1,41 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getRepo", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["repo"], + "properties": { + "repo": { + "type": "string", + "format": "at-uri", + "description": "AT-URI of the sh.tangled.repo record to fetch." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo record." + } + } + } + } + } + } +} diff --git a/lexicons/repo/getRepoByRepoDid.json b/lexicons/repo/getRepoByRepoDid.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getRepoByRepoDid.json @@ -0,0 +1,41 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getRepoByRepoDid", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["repoDid"], + "properties": { + "repoDid": { + "type": "string", + "format": "did", + "description": "Repo DID whose sh.tangled.repo record to fetch." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo record." + } + } + } + } + } + } +} diff --git a/lexicons/repo/getRepos.json b/lexicons/repo/getRepos.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/getRepos.json @@ -0,0 +1,58 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.getRepos", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["repos"], + "properties": { + "repos": { + "type": "array", + "items": { + "type": "string", + "format": "at-uri" + }, + "maxLength": 50, + "description": "AT-URIs of the sh.tangled.repo records to fetch. At most 50 per request." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["items"], + "properties": { + "items": { + "type": "array", + "items": { + "type": "ref", + "ref": "#recordView" + } + } + } + } + } + }, + "recordView": { + "type": "object", + "required": ["uri", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "value": { + "type": "unknown", + "description": "Embedded sh.tangled.repo record." + } + } + } + } +} diff --git a/lexicons/repo/issue/countStates.json b/lexicons/repo/issue/countStates.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/issue/countStates.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.issue.countStates", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "at-uri", + "description": "Issue AT-URI whose state records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/issue/countStatesBy.json b/lexicons/repo/issue/countStatesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/issue/countStatesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.issue.countStatesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose issue-state authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/pull/countStatuses.json b/lexicons/repo/pull/countStatuses.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/pull/countStatuses.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.pull.countStatuses", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "at-uri", + "description": "Pull AT-URI whose status records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/repo/pull/countStatusesBy.json b/lexicons/repo/pull/countStatusesBy.json new file mode 100644 --- /dev/null +++ b/lexicons/repo/pull/countStatusesBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.repo.pull.countStatusesBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose pull-status authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/search/query.json b/lexicons/search/query.json new file mode 100644 --- /dev/null +++ b/lexicons/search/query.json @@ -0,0 +1,101 @@ +{ + "lexicon": 1, + "id": "sh.tangled.search.query", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["q"], + "properties": { + "q": { + "type": "string", + "minLength": 1, + "description": "Full-text search query." + }, + "nsid": { + "type": "string", + "format": "nsid", + "description": "Restrict to records of this collection." + }, + "author": { + "type": "string", + "format": "did", + "description": "Restrict to records authored by this DID." + }, + "repo": { + "type": "string", + "format": "did", + "description": "Restrict to records under this repo DID." + }, + "since": { + "type": "string", + "format": "datetime", + "description": "Restrict to records created at or after this time." + }, + "until": { + "type": "string", + "format": "datetime", + "description": "Restrict to records created at or before this time." + }, + "cursor": { + "type": "string", + "description": "Pagination cursor" + }, + "limit": { + "type": "integer", + "minimum": 1, + "maximum": 1000, + "default": 50 + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["hits"], + "properties": { + "hits": { + "type": "array", + "items": { + "type": "ref", + "ref": "#hit" + } + }, + "cursor": { + "type": "string" + } + } + } + } + }, + "hit": { + "type": "object", + "required": ["uri", "nsid", "score", "value"], + "properties": { + "uri": { + "type": "string", + "format": "at-uri" + }, + "cid": { + "type": "string", + "format": "cid" + }, + "nsid": { + "type": "string", + "format": "nsid", + "description": "Collection of the matched record." + }, + "score": { + "type": "unknown", + "description": "Relevance score of the hit, a floating-point number where higher ranks first." + }, + "value": { + "type": "unknown", + "description": "Embedded matched record." + } + } + } + } +} diff --git a/lexicons/spindle/countMembers.json b/lexicons/spindle/countMembers.json new file mode 100644 --- /dev/null +++ b/lexicons/spindle/countMembers.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.spindle.countMembers", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Spindle identifier whose member records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/spindle/countMembersBy.json b/lexicons/spindle/countMembersBy.json new file mode 100644 --- /dev/null +++ b/lexicons/spindle/countMembersBy.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.spindle.countMembersBy", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Actor DID whose spindle-member authorings to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/spindle/countSpindles.json b/lexicons/spindle/countSpindles.json new file mode 100644 --- /dev/null +++ b/lexicons/spindle/countSpindles.json @@ -0,0 +1,39 @@ +{ + "lexicon": 1, + "id": "sh.tangled.spindle.countSpindles", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "format": "did", + "description": "Owner DID whose spindle records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +} diff --git a/lexicons/string/countStrings.json b/lexicons/string/countStrings.json new file mode 100644 --- /dev/null +++ b/lexicons/string/countStrings.json @@ -0,0 +1,38 @@ +{ + "lexicon": 1, + "id": "sh.tangled.string.countStrings", + "defs": { + "main": { + "type": "query", + "parameters": { + "type": "params", + "required": ["subject"], + "properties": { + "subject": { + "type": "string", + "description": "Scope identifier whose string records to list." + } + } + }, + "output": { + "encoding": "application/json", + "schema": { + "type": "object", + "required": ["count", "distinctAuthors"], + "properties": { + "count": { + "type": "integer", + "minimum": 0, + "description": "Total number of matching records." + }, + "distinctAuthors": { + "type": "integer", + "minimum": 0, + "description": "Number of distinct authors among the matching records." + } + } + } + } + } + } +}