php artisan vendor:publish --tag=filament-flex-fields-migrations
php artisan migrate

FLEX_FIELDS_SCHEMA_RESOURCE_ENABLED=true

'schema' => [
    'resource_enabled' => true,
    'navigation_group' => 'Flex Fields',
    'navigation_sort' => 90,
],

FLEX_FIELDS_SCHEMA_RESOURCE_ENABLED=true
FLEX_FIELDS_SCHEMA_MANAGEMENT_PAGE=false

FLEX_FIELDS_SCHEMA_REGISTRY_DB=false

use Bjanczak\FilamentFlexFields\Support\Enterprise\SchemaRegistry;

$v1 = SchemaRegistry::publish('crm-lead', $schemaArray, '[email protected]', SchemaRegistry::STATE_DRAFT);
SchemaRegistry::setApprovalState('crm-lead', $v1, SchemaRegistry::STATE_LIVE);
$rolled = SchemaRegistry::rollback('crm-lead', $v1); // new live version with old schema payload
$history = SchemaRegistry::versions('crm-lead');

FLEX_FIELDS_SCHEMA_SYNC_FROM_DB=true
FLEX_FIELDS_SCHEMA_SYNC_ON_SAVE=true
FLEX_FIELDS_SCHEMA_DEFAULT_TARGET=App\Models\Model

use Bjanczak\FilamentFlexFields\Filament\Concerns\InteractsWithFlexFieldSchemas;
use Bjanczak\FilamentFlexFields\Support\Schema\FlexFieldStudio;

// In a Filament Resource — trait helpers
class LeadResource extends Resource
{
    use InteractsWithFlexFieldSchemas;

    public static function form(Schema $schema): Schema
    {
        return $schema->components([
            // …your core fields…
            ...static::flexFieldFormLayoutForResource('CRM attributes', collapsible: true),
        ]);
    }

    public static function table(Table $table): Table
    {
        return $table->columns([
            // …core columns…
            ...static::flexFieldTableColumnsForResource(),
        ]);
    }
}

// Or fluent API directly
$section = app(FlexFieldStudio::class)
    ->form()
    ->forModel(\App\Models\Lead::class)
    ->record($lead) // optional — resolves tenant + RBAC from context
    ->only(['deal_stage', 'company_name'])
    ->section();

use Filament\Schemas\Schema;

public static function form(Schema $schema): Schema
{
    return $schema->components([
        ...static::flexFieldFormLayoutForResource('CRM attributes', collapsible: true),
    ]);
}

$group->publishToRegistry($actor, SchemaRegistry::STATE_REVIEW);
$group->rollbackRegistryVersion(3);

// AppServiceProvider::boot()
config([
    'filament-flex-fields.schema.tenant_resolver' => fn (?object $context): ?string => Filament::getTenant()?->id,
    'filament-flex-fields.schema.rbac_user_key_resolver' => fn (?object $context): ?string => auth()->user()?->email,
    'filament-flex-fields.schema.scope_resource_by_tenant' => true,
]);

use Bjanczak\FilamentFlexFields\Models\FlexFieldGroup;
use Bjanczak\FilamentFlexFields\Support\Enterprise\SchemaRegistry;

$group = FlexFieldGroup::query()->where('slug', 'booking')->first();

// schema_id = slug, or "tenantId:slug" when tenant_id is set
$version = $group->publishToRegistry(auth()->user()?->email, SchemaRegistry::STATE_LIVE);

// Restores fields JSON (and name from schema label) from a prior version; creates a new live version in SchemaRegistry
$record = $group->rollbackRegistryVersion(1);

// AppServiceProvider::boot()
use Illuminate\Support\Facades\Gate;

Gate::define('manageFlexFieldSchemas', fn (\App\Models\User $user): bool => $user->isAdmin());

use Bjanczak\FilamentFlexFields\Models\FlexFieldGroup;

Gate::policy(FlexFieldGroup::class, YourFlexFieldGroupPolicy::class);

// config/filament-flex-fields.php
'schema' => [
    'resource_enabled' => env('FLEX_FIELDS_SCHEMA_RESOURCE_ENABLED', false),
    'management_page_enabled' => env('FLEX_FIELDS_SCHEMA_MANAGEMENT_PAGE', true), // Beta; set to false in production.
    'navigation_group' => env('FLEX_FIELDS_SCHEMA_NAV_GROUP', 'Flex Fields'),
    'navigation_sort' => (int) env('FLEX_FIELDS_SCHEMA_NAV_SORT', 90),
    'registry_persistence' => env('FLEX_FIELDS_SCHEMA_REGISTRY_DB', true),
    'sync_from_database' => env('FLEX_FIELDS_SCHEMA_SYNC_FROM_DB', true),
    'sync_on_save' => env('FLEX_FIELDS_SCHEMA_SYNC_ON_SAVE', true),
    'default_target_type' => env('FLEX_FIELDS_SCHEMA_DEFAULT_TARGET', 'App\\Models\\Model'),
    'policy_ability' => env('FLEX_FIELDS_SCHEMA_POLICY_ABILITY', 'manageFlexFieldSchemas'),
    'tenant_resolver' => null, // callable (?object $context): ?string
    'rbac_user_key_resolver' => null, // callable (?object $context): ?string
    'scope_resource_by_tenant' => env('FLEX_FIELDS_SCHEMA_SCOPE_BY_TENANT', false),
],

use Bjanczak\FilamentFlexFields\Support\Enterprise\SchemaRegistry;
use Bjanczak\FilamentFlexFields\Support\Enterprise\Schema\SchemaVersionConflict;

// Read when opening the editor, not immediately before saving.
$openedVersion = SchemaRegistry::currentVersion($schemaId);

// After your application authorizes schema configuration:
try {
    $newVersion = SchemaRegistry::publish(
        schemaId: $schemaId,
        schema: $schema,
        actor: (string) $actor->getAuthIdentifier(),
        state: SchemaRegistry::STATE_DRAFT,
        expectedVersion: $openedVersion,
    );
} catch (SchemaVersionConflict $conflict) {
    // Keep the user's changes and ask them to reload/compare the newer snapshot.
    // $conflict->expected and $conflict->actual contain only version numbers.
}

$restored = SchemaRegistry::rollback(
    schemaId: $schemaId,
    version: 3,
    expectedVersion: $openedVersion,
);

use Bjanczak\FilamentFlexFields\Support\Schema\SchemaImportExport;

$exchange = app(SchemaImportExport::class);
$schema = $exchange->import($json); // Version, shape and bounded-data validation.
$exchange->assertValid($schema);    // Use the same checks for direct array updates.

use Bjanczak\FilamentFlexFields\Support\Values\Submission\FieldValueContract;
use Illuminate\Support\Facades\DB;

$contracts = [
    new FieldValueContract('title', ['sometimes', 'string', 'max:120']),
    new FieldValueContract(
        path: 'tags',
        rules: ['sometimes', 'array', 'list', 'max:20'],
        nestedRules: ['*' => ['string', 'max:40', 'distinct']],
    ),
    new FieldValueContract(
        path: 'translations',
        rules: ['sometimes', 'array:en,pl'],
        nestedRules: [
            'en' => ['sometimes', 'nullable', 'string', 'max:500'],
            'pl' => ['sometimes', 'nullable', 'string', 'max:500'],
        ],
    ),
];

$submittedValues = $request->input('flex_field_values');
$user = $request->user();
$tenant = $currentTenant; // Resolve this through your authenticated tenant context.

DB::transaction(function () use (
    $recordId, $submittedValues, $contracts, $user, $tenant,
) {
    $record = Article::query()
        ->where('tenant_id', $tenant->getKey())
        ->lockForUpdate()
        ->findOrFail($recordId);

    $record->applySubmittedFlexFieldValues(
        values: $submittedValues,
        contracts: $contracts,
        authorizeRecord: fn ($record): bool => $user->can('update', $record),
        authorizeField: fn (FieldValueContract $field): bool =>
            $user->can('updateFlexField', [$record, $field->path]),
    )->save();
});

// config/filament-flex-fields.php
'schema' => [
    // Keep your other schema settings here.
    'configuration_references' => [
        'user_select' => [
            'models' => [App\Models\User::class],
            'views' => ['forms.user-option'],
        ],
        'select' => [
            'views' => ['forms.product-option'],
        ],
        'slug' => [
            'models' => [App\Models\Article::class],
        ],
        'verification_code' => [
            'methods' => ['verifyCode'],
        ],
        'todo_list' => [
            'methods' => ['loadTasks'],
        ],
    ],
],

use Bjanczak\FilamentFlexFields\Enums\FieldType;
use Bjanczak\FilamentFlexFields\Support\Schema\Configuration\BuiltinConfigurationOptions;

$type = FieldType::Select;
$unknown = BuiltinConfigurationOptions::unsupportedKeys(
    type: $type,
    defaults: $type->defaultConfig(),
    config: $savedField['config'] ?? [],
);