university-creator 0.1.0__tar.gz

university_creator-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.nox/
+.tox/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# Django
+*.sqlite3
+# Local user uploads (never the university.media source package).
+/media/
+/private-media/
+example_project/media/
+example_project/private-media/
+staticfiles/
+
+# Secrets — never commit
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+
+# Editors / OS
+.idea/
+.vscode/
+.DS_Store
+Thumbs.db

university_creator-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

university_creator-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.5
+Name: university-creator
+Version: 0.1.0
+Summary: University Creator: creator profiles, verification, linked social accounts, media kits, campaigns, sponsorships and analytics for the University platform.
+Project-URL: Homepage, https://github.com/NzeStan/University
+Project-URL: Documentation, https://github.com/NzeStan/University/blob/main/docs/modules/creator.md
+Project-URL: Source, https://github.com/NzeStan/University
+Project-URL: Changelog, https://github.com/NzeStan/University/blob/main/CHANGELOG.md
+Author-email: Ifeanyi Stanley <nnamaniifeanyi10@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: africa,campaigns,creator,django,drf,influencer,media-kit,sponsorship,university
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: university-core<0.2,>=0.1
+Provides-Extra: test
+Requires-Dist: drf-spectacular>=0.27; extra == 'test'
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest-django>=4.8; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# university-creator
+
+The creator economy for the [University platform](https://github.com/NzeStan/University):
+creator profiles, verification, linked social accounts, media kits, sponsorship campaigns and
+analytics. This is an optional *level two* module that depends only on `university-core`.
+
+- **Profiles** follow each user's own privacy settings and blocks. They carry categories, a
+  verified badge on the public profile, and a discovery list with filters (category, country,
+  verified, reach, open to sponsorships).
+- **Verification.** Requests are reviewed by someone other than the creator; decisions are audited
+  and can be revoked.
+- **Linked accounts** (TikTok, Instagram, YouTube, X, Facebook, Spotify, Audiomack, Boomplay …):
+  - Every platform sits behind a `SocialProvider` adapter.
+  - Ownership is proven with a bio challenge code or confirmed by a reviewer.
+  - Only confirmed follower counts count toward a creator's reach.
+  - A verified account can belong to only one creator, which prevents impersonation.
+  - No platform passwords or tokens are stored.
+- **Media kits** have public, unlisted (revocable link) or private visibility, and hold validated
+  audience breakdowns, a rate card, highlights and live platform stats.
+- **Campaigns and sponsorships:**
+  - Brands invite creators, or creators apply; brands shortlist and accept.
+  - Slots are enforced in the database, and requirements (verified only, minimum reach) are
+    checked on both paths.
+  - Agreed fees, deliverables with review, and ad-disclosure confirmation are all supported.
+  - Campaigns opt in to moderation, with reports going to the sponsor's moderators.
+- **Analytics** are daily aggregates only (followers, reactions, comments, reposts, mentions,
+  profile and media kit views, external follower growth). Views are de-duplicated without storing
+  who viewed.
+
+```bash
+pip install university-creator
+```
+
+```python
+INSTALLED_APPS += ["university.creator"]
+```
+
+See [the module documentation](../../docs/modules/creator.md).

university_creator-0.1.0/README.md

@@ -0,0 +1,38 @@
+# university-creator
+
+The creator economy for the [University platform](https://github.com/NzeStan/University):
+creator profiles, verification, linked social accounts, media kits, sponsorship campaigns and
+analytics. This is an optional *level two* module that depends only on `university-core`.
+
+- **Profiles** follow each user's own privacy settings and blocks. They carry categories, a
+  verified badge on the public profile, and a discovery list with filters (category, country,
+  verified, reach, open to sponsorships).
+- **Verification.** Requests are reviewed by someone other than the creator; decisions are audited
+  and can be revoked.
+- **Linked accounts** (TikTok, Instagram, YouTube, X, Facebook, Spotify, Audiomack, Boomplay …):
+  - Every platform sits behind a `SocialProvider` adapter.
+  - Ownership is proven with a bio challenge code or confirmed by a reviewer.
+  - Only confirmed follower counts count toward a creator's reach.
+  - A verified account can belong to only one creator, which prevents impersonation.
+  - No platform passwords or tokens are stored.
+- **Media kits** have public, unlisted (revocable link) or private visibility, and hold validated
+  audience breakdowns, a rate card, highlights and live platform stats.
+- **Campaigns and sponsorships:**
+  - Brands invite creators, or creators apply; brands shortlist and accept.
+  - Slots are enforced in the database, and requirements (verified only, minimum reach) are
+    checked on both paths.
+  - Agreed fees, deliverables with review, and ad-disclosure confirmation are all supported.
+  - Campaigns opt in to moderation, with reports going to the sponsor's moderators.
+- **Analytics** are daily aggregates only (followers, reactions, comments, reposts, mentions,
+  profile and media kit views, external follower growth). Views are de-duplicated without storing
+  who viewed.
+
+```bash
+pip install university-creator
+```
+
+```python
+INSTALLED_APPS += ["university.creator"]
+```
+
+See [the module documentation](../../docs/modules/creator.md).

university_creator-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "university-creator"
+dynamic = ["version"]
+description = "University Creator: creator profiles, verification, linked social accounts, media kits, campaigns, sponsorships and analytics for the University platform."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Ifeanyi Stanley", email = "nnamaniifeanyi10@gmail.com" }]
+keywords = ["django", "drf", "university", "creator", "influencer", "sponsorship", "media-kit", "campaigns", "africa"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Framework :: Django :: 6.1",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+# Level-two modules depend only on Core (same minor series).
+dependencies = ["university-core>=0.1,<0.2"]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-django>=4.8", "pytest-cov>=5", "drf-spectacular>=0.27"]
+
+[project.urls]
+Homepage = "https://github.com/NzeStan/University"
+Documentation = "https://github.com/NzeStan/University/blob/main/docs/modules/creator.md"
+Source = "https://github.com/NzeStan/University"
+Changelog = "https://github.com/NzeStan/University/blob/main/CHANGELOG.md"
+
+[tool.hatch.version]
+path = "src/university/creator/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/university"]
+exclude = ["**/__pycache__"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/university", "tests", "README.md", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+pythonpath = ["."]
+testpaths = ["tests"]
+addopts = "-ra --strict-markers"
+markers = ["security: security regression tests"]

university_creator-0.1.0/src/university/creator/__init__.py

@@ -0,0 +1,15 @@
+"""University Creator — creator profiles, verification, media kits, campaigns and analytics.
+
+An optional *level two* module that depends only on University Core::
+
+    pip install university-creator
+
+    INSTALLED_APPS = [..., *CORE_APPS, "university.creator"]
+
+External platforms (TikTok, Instagram, YouTube, X, Facebook, Spotify …) are
+reached only through :class:`university.creator.providers.SocialProvider`
+adapters, configured per deployment. Analytics are daily aggregates built
+from ids-only platform events; no viewer-level records are kept.
+"""
+
+__version__ = "0.1.0"

university_creator-0.1.0/src/university/creator/admin.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.contrib import admin
+
+from university.creator.models import Campaign, CreatorCategory, CreatorProfile, LinkedAccount, VerificationRequest
+
+
+@admin.register(CreatorCategory)
+class CreatorCategoryAdmin(admin.ModelAdmin):
+    list_display = ("name", "key", "is_active", "position")
+    list_editable = ("is_active", "position")
+
+
+class LinkedAccountInline(admin.TabularInline):
+    model = LinkedAccount
+    extra = 0
+    fields = ("provider", "handle", "ownership", "follower_count", "count_source", "last_synced_at")
+    readonly_fields = ("ownership", "count_source", "last_synced_at")
+
+
+@admin.register(CreatorProfile)
+class CreatorProfileAdmin(admin.ModelAdmin):
+    list_display = ("user", "headline", "verification_status", "verified_reach", "status")
+    list_filter = ("verification_status", "status", "categories")
+    search_fields = ("user__handle", "user__display_name", "headline")
+    raw_id_fields = ("user",)
+    # Verification changes go through the review workflow (audited), not the admin.
+    readonly_fields = ("verification_status", "verified_at", "verified_reach")
+    inlines = (LinkedAccountInline,)
+
+
+@admin.register(VerificationRequest)
+class VerificationRequestAdmin(admin.ModelAdmin):
+    list_display = ("profile", "status", "created_at", "reviewed_by", "reviewed_at")
+    list_filter = ("status",)
+    raw_id_fields = ("profile", "reviewed_by")
+    readonly_fields = ("status", "reviewed_by", "reviewed_at", "decision_reason")
+
+    def has_add_permission(self, request: Any) -> bool:
+        return False
+
+
+@admin.register(Campaign)
+class CampaignAdmin(admin.ModelAdmin):
+    list_display = ("title", "brand_name", "status", "visibility", "accepted_count", "slots", "hidden_at")
+    list_filter = ("status", "visibility")
+    search_fields = ("title", "brand_name")
+    raw_id_fields = ("owner",)
+    readonly_fields = ("accepted_count", "published_at", "closed_at", "hidden_at", "hidden_reason")
+
+    def get_queryset(self, request: Any) -> Any:
+        return Campaign.all_objects.all()

university_creator-0.1.0/src/university/creator/api/v1/serializers.py

@@ -0,0 +1,374 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rest_framework import serializers
+
+from university.core.api.schema import extend_schema_field
+from university.core.api.serializers import StrictModelSerializer
+from university.creator.constants import CampaignVisibility, KitVisibility, ProfileStatus
+from university.creator.models import (
+    Campaign,
+    CreatorCategory,
+    CreatorProfile,
+    Deliverable,
+    LinkedAccount,
+    MediaKit,
+    Participation,
+    VerificationRequest,
+)
+from university.creator.providers import providers
+
+
+class CreatorPersonSerializer(serializers.Serializer):
+    id = serializers.UUIDField()
+    handle = serializers.CharField(allow_null=True)
+    display_name = serializers.CharField()
+
+
+def person(user: Any) -> dict[str, Any] | None:
+    if user is None or not user.is_active:
+        return None
+    return {"id": user.pk, "handle": user.handle, "display_name": user.display_name or user.handle or ""}
+
+
+class CreatorCategorySerializer(StrictModelSerializer):
+    class Meta:
+        model = CreatorCategory
+        fields = ("key", "name")
+        read_only_fields = fields
+
+
+class CreatorProviderSerializer(serializers.Serializer):
+    key = serializers.CharField()
+    label = serializers.CharField()
+    automatic_verification = serializers.BooleanField()
+
+
+def provider_list() -> list[dict[str, Any]]:
+    return [
+        {"key": key, "label": p.label, "automatic_verification": p.supports_lookup} for key, p in providers().items()
+    ]
+
+
+# ---------------------------------------------------------------- accounts
+class CreatorLinkedAccountSerializer(StrictModelSerializer):
+    """Public view of a linked account."""
+
+    class Meta:
+        model = LinkedAccount
+        fields = ("id", "provider", "handle", "url", "display_name", "follower_count", "count_source", "ownership")
+        read_only_fields = fields
+
+
+class CreatorOwnLinkedAccountSerializer(CreatorLinkedAccountSerializer):
+    """The owner's view: includes the challenge code to place in their bio."""
+
+    class Meta(CreatorLinkedAccountSerializer.Meta):
+        fields = (
+            *CreatorLinkedAccountSerializer.Meta.fields,
+            "challenge",
+            "is_public",
+            "verified_at",
+            "last_synced_at",
+        )
+        read_only_fields = fields
+
+
+class CreatorLinkAccountSerializer(serializers.Serializer):
+    provider = serializers.CharField(max_length=32)
+    handle = serializers.CharField(max_length=100)
+    follower_count = serializers.IntegerField(min_value=0, required=False, allow_null=True)
+
+
+class CreatorAccountUpdateSerializer(serializers.Serializer):
+    follower_count = serializers.IntegerField(min_value=0, required=False, allow_null=True)
+    is_public = serializers.BooleanField(required=False, allow_null=True)
+
+
+class CreatorConfirmAccountSerializer(serializers.Serializer):
+    follower_count = serializers.IntegerField(min_value=0, required=False, allow_null=True)
+
+
+# ---------------------------------------------------------------- profiles
+class CreatorProfileSerializer(StrictModelSerializer):
+    user = serializers.SerializerMethodField()
+    categories = CreatorCategorySerializer(many=True, read_only=True)
+    linked_accounts = serializers.SerializerMethodField()
+    is_verified = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = CreatorProfile
+        fields = (
+            "id",
+            "user",
+            "headline",
+            "bio",
+            "categories",
+            "city",
+            "country",
+            "languages",
+            "open_to_sponsorships",
+            "business_email",
+            "is_verified",
+            "verification_status",
+            "verified_at",
+            "verified_reach",
+            "linked_accounts",
+            "created_at",
+        )
+        read_only_fields = fields
+
+    @extend_schema_field(CreatorPersonSerializer(allow_null=True))
+    def get_user(self, obj: CreatorProfile) -> dict[str, Any] | None:
+        return person(obj.user)
+
+    @extend_schema_field(CreatorLinkedAccountSerializer(many=True))
+    def get_linked_accounts(self, obj: CreatorProfile) -> list[dict[str, Any]]:
+        return CreatorLinkedAccountSerializer(obj.linked_accounts.filter(is_public=True), many=True).data
+
+
+class CreatorOwnProfileSerializer(CreatorProfileSerializer):
+    class Meta(CreatorProfileSerializer.Meta):
+        fields = (*CreatorProfileSerializer.Meta.fields, "status", "is_discoverable")
+        read_only_fields = fields
+
+
+class CreatorProfileWriteSerializer(serializers.Serializer):
+    headline = serializers.CharField(max_length=120, required=False, allow_blank=True)
+    bio = serializers.CharField(max_length=5000, required=False, allow_blank=True)
+    categories = serializers.ListField(child=serializers.CharField(max_length=40), required=False, max_length=10)
+    city = serializers.CharField(max_length=100, required=False, allow_blank=True)
+    country = serializers.RegexField(r"^[A-Za-z]{2}$", required=False, allow_blank=True)
+    languages = serializers.ListField(child=serializers.CharField(max_length=10), required=False, max_length=10)
+    is_discoverable = serializers.BooleanField(required=False)
+    open_to_sponsorships = serializers.BooleanField(required=False)
+    business_email = serializers.EmailField(required=False, allow_blank=True)
+    status = serializers.ChoiceField(choices=ProfileStatus.choices, required=False)
+
+
+# ------------------------------------------------------------ verification
+class CreatorVerificationRequestSerializer(StrictModelSerializer):
+    profile = serializers.SerializerMethodField()
+
+    class Meta:
+        model = VerificationRequest
+        fields = ("id", "profile", "status", "statement", "links", "decision_reason", "reviewed_at", "created_at")
+        read_only_fields = fields
+
+    @extend_schema_field(CreatorPersonSerializer(allow_null=True))
+    def get_profile(self, obj: VerificationRequest) -> dict[str, Any] | None:
+        return person(obj.profile.user)
+
+
+class CreatorVerificationCreateSerializer(serializers.Serializer):
+    statement = serializers.CharField(max_length=3000)
+    links = serializers.ListField(child=serializers.CharField(max_length=300), required=False, max_length=10)
+
+
+class CreatorReasonSerializer(serializers.Serializer):
+    reason = serializers.CharField(max_length=500, required=False, allow_blank=True, default="")
+
+
+# --------------------------------------------------------------- media kit
+class CreatorMediaKitSerializer(StrictModelSerializer):
+    profile = serializers.SerializerMethodField()
+    platform_stats = serializers.SerializerMethodField()
+
+    class Meta:
+        model = MediaKit
+        fields = ("profile", "summary", "audience", "rates", "highlights", "platform_stats", "updated_at")
+        read_only_fields = fields
+
+    @extend_schema_field(CreatorProfileSerializer)
+    def get_profile(self, obj: MediaKit) -> dict[str, Any]:
+        return CreatorProfileSerializer(obj.profile).data
+
+    def get_platform_stats(self, obj: MediaKit) -> dict[str, Any] | None:
+        return self.context.get("platform_stats") if obj.show_platform_stats else None
+
+
+class CreatorOwnMediaKitSerializer(CreatorMediaKitSerializer):
+    class Meta(CreatorMediaKitSerializer.Meta):
+        fields = (*CreatorMediaKitSerializer.Meta.fields, "visibility", "share_token", "show_platform_stats")
+        read_only_fields = fields
+
+
+class CreatorMediaKitWriteSerializer(serializers.Serializer):
+    visibility = serializers.ChoiceField(choices=KitVisibility.choices, required=False)
+    summary = serializers.CharField(max_length=5000, required=False, allow_blank=True)
+    audience = serializers.JSONField(required=False)
+    rates = serializers.JSONField(required=False)
+    highlights = serializers.JSONField(required=False)
+    show_platform_stats = serializers.BooleanField(required=False)
+
+
+# --------------------------------------------------------------- campaigns
+class CreatorScopeRefSerializer(serializers.Serializer):
+    type = serializers.CharField()
+    id = serializers.CharField()
+
+
+class CreatorCampaignSerializer(StrictModelSerializer):
+    categories = CreatorCategorySerializer(many=True, read_only=True)
+    sponsor = serializers.SerializerMethodField()
+    slots_left = serializers.SerializerMethodField()
+    viewer = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Campaign
+        fields = (
+            "id",
+            "brand_name",
+            "title",
+            "brief",
+            "categories",
+            "sponsor",
+            "status",
+            "visibility",
+            "slots",
+            "slots_left",
+            "budget_minor",
+            "currency",
+            "deliverables_summary",
+            "application_deadline",
+            "starts_on",
+            "ends_on",
+            "verified_only",
+            "min_verified_reach",
+            "disclosure_required",
+            "published_at",
+            "viewer",
+            "created_at",
+        )
+        read_only_fields = fields
+
+    @extend_schema_field(CreatorScopeRefSerializer(allow_null=True))
+    def get_sponsor(self, obj: Campaign) -> dict[str, str] | None:
+        return {"type": obj.scope_type, "id": obj.scope_id} if obj.scope_type else None
+
+    def get_slots_left(self, obj: Campaign) -> int | None:
+        return None if obj.slots is None else max(obj.slots - obj.accepted_count, 0)
+
+    @extend_schema_field(serializers.DictField())
+    def get_viewer(self, obj: Campaign) -> dict[str, Any]:
+        participation = (self.context.get("participations") or {}).get(obj.pk)
+        return {
+            "can_manage": bool((self.context.get("managed") or {}).get(obj.pk)),
+            "participation_id": participation.pk if participation else None,
+            "participation_status": participation.status if participation else None,
+        }
+
+
+class CreatorCampaignWriteSerializer(serializers.Serializer):
+    brand_name = serializers.CharField(max_length=120)
+    title = serializers.CharField(max_length=160)
+    brief = serializers.CharField(max_length=10000)
+    categories = serializers.ListField(child=serializers.CharField(max_length=40), required=False, max_length=10)
+    visibility = serializers.ChoiceField(choices=CampaignVisibility.choices, required=False)
+    slots = serializers.IntegerField(min_value=1, required=False, allow_null=True)
+    budget_minor = serializers.IntegerField(min_value=0, required=False, allow_null=True)
+    currency = serializers.RegexField(r"^[A-Z]{3}$", required=False)
+    deliverables_summary = serializers.CharField(max_length=5000, required=False, allow_blank=True)
+    application_deadline = serializers.DateTimeField(required=False, allow_null=True)
+    starts_on = serializers.DateField(required=False, allow_null=True)
+    ends_on = serializers.DateField(required=False, allow_null=True)
+    verified_only = serializers.BooleanField(required=False)
+    min_verified_reach = serializers.IntegerField(min_value=0, required=False)
+    disclosure_required = serializers.BooleanField(required=False)
+    sponsor_type = serializers.CharField(max_length=32, required=False, allow_blank=True, default="", write_only=True)
+    sponsor_id = serializers.CharField(max_length=64, required=False, allow_blank=True, default="", write_only=True)
+
+
+class CreatorParticipationSerializer(StrictModelSerializer):
+    creator = serializers.SerializerMethodField()
+    campaign = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Participation
+        fields = (
+            "id",
+            "campaign",
+            "creator",
+            "status",
+            "pitch",
+            "proposed_fee_minor",
+            "agreed_fee_minor",
+            "fee_paid_at",
+            "note",
+            "decided_at",
+            "created_at",
+        )
+        read_only_fields = fields
+
+    @extend_schema_field(serializers.DictField())
+    def get_creator(self, obj: Participation) -> dict[str, Any]:
+        profile = obj.profile
+        return {
+            "profile_id": profile.pk,
+            "user": person(profile.user),
+            "is_verified": profile.is_verified,
+            "verified_reach": profile.verified_reach,
+        }
+
+    @extend_schema_field(serializers.DictField())
+    def get_campaign(self, obj: Participation) -> dict[str, Any]:
+        campaign = obj.campaign
+        return {
+            "id": campaign.pk,
+            "title": campaign.title,
+            "brand_name": campaign.brand_name,
+            "currency": campaign.currency,
+        }
+
+
+class CreatorApplySerializer(serializers.Serializer):
+    pitch = serializers.CharField(max_length=3000)
+    proposed_fee_minor = serializers.IntegerField(min_value=0, required=False, allow_null=True)
+
+
+class CreatorInviteSerializer(serializers.Serializer):
+    profile_id = serializers.UUIDField()
+    note = serializers.CharField(max_length=500, required=False, allow_blank=True, default="")
+
+
+class CreatorDecisionSerializer(serializers.Serializer):
+    action = serializers.ChoiceField(choices=["shortlist", "accept", "decline", "complete", "cancel", "withdraw"])
+    fee_minor = serializers.IntegerField(min_value=0, required=False, allow_null=True)
+    note = serializers.CharField(max_length=500, required=False, allow_blank=True, default="")
+
+
+class CreatorDeliverableSerializer(StrictModelSerializer):
+    class Meta:
+        model = Deliverable
+        fields = (
+            "id",
+            "title",
+            "description",
+            "due_at",
+            "status",
+            "submission_url",
+            "submission_note",
+            "disclosure_confirmed",
+            "submitted_at",
+            "reviewed_at",
+            "review_note",
+        )
+        read_only_fields = fields
+
+
+class CreatorDeliverableWriteSerializer(serializers.Serializer):
+    title = serializers.CharField(max_length=160)
+    description = serializers.CharField(max_length=5000, required=False, allow_blank=True)
+    due_at = serializers.DateTimeField(required=False, allow_null=True)
+
+
+class CreatorSubmitSerializer(serializers.Serializer):
+    url = serializers.URLField(max_length=500)
+    note = serializers.CharField(max_length=2000, required=False, allow_blank=True, default="")
+    disclosure_confirmed = serializers.BooleanField(default=False)
+
+
+class CreatorReviewSerializer(serializers.Serializer):
+    approve = serializers.BooleanField()
+    note = serializers.CharField(max_length=1000, required=False, allow_blank=True, default="")