// This file is generated by TypeBuilder_h.template.

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef content_protocol_Storage_h
#define content_protocol_Storage_h

#include "content/common/content_export.h"
#include "content/browser/devtools/protocol/protocol.h"
// For each imported domain we generate a ValueConversions struct instead of a full domain definition
// and include Domain::API version from there.
#include "content/browser/devtools/protocol/browser.h"
#include "content/browser/devtools/protocol/network.h"

namespace content {
namespace protocol {
namespace Storage {
using SerializedStorageKey = String;
using StorageType = String;
class UsageForType;
class TrustTokens;
using StorageBucketsDurability = String;
class StorageBucket;
class StorageBucketInfo;

// ------------- Forward and enum declarations.

namespace StorageTypeEnum {
inline constexpr char Cookies[] = "cookies";
inline constexpr char File_systems[] = "file_systems";
inline constexpr char Indexeddb[] = "indexeddb";
inline constexpr char Local_storage[] = "local_storage";
inline constexpr char Shader_cache[] = "shader_cache";
inline constexpr char Websql[] = "websql";
inline constexpr char Service_workers[] = "service_workers";
inline constexpr char Cache_storage[] = "cache_storage";
inline constexpr char Storage_buckets[] = "storage_buckets";
inline constexpr char All[] = "all";
inline constexpr char Other[] = "other";
} // namespace StorageTypeEnum

namespace StorageBucketsDurabilityEnum {
inline constexpr char Relaxed[] = "relaxed";
inline constexpr char Strict[] = "strict";
} // namespace StorageBucketsDurabilityEnum

// ------------- Type and builder declarations.

class CONTENT_EXPORT UsageForType : public ::crdtp::ProtocolObject<UsageForType> {
public:
    ~UsageForType() override;  // Defined below

    String GetStorageType() { return m_storageType; }
    void SetStorageType(const String& value);  // Defined below

    double GetUsage() { return m_usage; }
    void SetUsage(double value);  // Defined below

    template<int STATE>
    class UsageForTypeBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            StorageTypeSet = 1 << 1,
            UsageSet = 1 << 2,
            AllFieldsSet = (StorageTypeSet | UsageSet | 0)};


        UsageForTypeBuilder<STATE | StorageTypeSet>& SetStorageType(const String& value);  // Defined below

        UsageForTypeBuilder<STATE | UsageSet>& SetUsage(double value);  // Defined below

        std::unique_ptr<UsageForType> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class UsageForType;
        UsageForTypeBuilder() : m_result(new UsageForType()) { }

        template<int STEP> UsageForTypeBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<UsageForTypeBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Storage::UsageForType> m_result;
    };

    static UsageForTypeBuilder<0> Create()
    {
        return UsageForTypeBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    UsageForType();  // Defined below

    String m_storageType;
    double m_usage;
};


class CONTENT_EXPORT TrustTokens : public ::crdtp::ProtocolObject<TrustTokens> {
public:
    ~TrustTokens() override;  // Defined below

    String GetIssuerOrigin() { return m_issuerOrigin; }
    void SetIssuerOrigin(const String& value);  // Defined below

    double GetCount() { return m_count; }
    void SetCount(double value);  // Defined below

    template<int STATE>
    class TrustTokensBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            IssuerOriginSet = 1 << 1,
            CountSet = 1 << 2,
            AllFieldsSet = (IssuerOriginSet | CountSet | 0)};


        TrustTokensBuilder<STATE | IssuerOriginSet>& SetIssuerOrigin(const String& value);  // Defined below

        TrustTokensBuilder<STATE | CountSet>& SetCount(double value);  // Defined below

        std::unique_ptr<TrustTokens> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class TrustTokens;
        TrustTokensBuilder() : m_result(new TrustTokens()) { }

        template<int STEP> TrustTokensBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<TrustTokensBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Storage::TrustTokens> m_result;
    };

    static TrustTokensBuilder<0> Create()
    {
        return TrustTokensBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    TrustTokens();  // Defined below

    String m_issuerOrigin;
    double m_count;
};


class CONTENT_EXPORT StorageBucket : public ::crdtp::ProtocolObject<StorageBucket> {
public:
    ~StorageBucket() override;  // Defined below

    String GetStorageKey() { return m_storageKey; }
    void SetStorageKey(const String& value);  // Defined below

    bool HasName() { return !!m_name; }
    String GetName(const String& defaultValue) const {
       return m_name.value_or(defaultValue);
    }
    const std::optional<String>& GetName() const {
       return m_name;
    }
    void SetName(const String& value);  // Defined below

    template<int STATE>
    class StorageBucketBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            StorageKeySet = 1 << 1,
            AllFieldsSet = (StorageKeySet | 0)};


        StorageBucketBuilder<STATE | StorageKeySet>& SetStorageKey(const String& value);  // Defined below

        StorageBucketBuilder<STATE>& SetName(const String& value);  // Defined below

        std::unique_ptr<StorageBucket> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class StorageBucket;
        StorageBucketBuilder() : m_result(new StorageBucket()) { }

        template<int STEP> StorageBucketBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<StorageBucketBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Storage::StorageBucket> m_result;
    };

    static StorageBucketBuilder<0> Create()
    {
        return StorageBucketBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    StorageBucket();  // Defined below

    String m_storageKey;
    std::optional<String> m_name;
};


class CONTENT_EXPORT StorageBucketInfo : public ::crdtp::ProtocolObject<StorageBucketInfo> {
public:
    ~StorageBucketInfo() override;  // Defined below

    protocol::Storage::StorageBucket* GetBucket() { return m_bucket.get(); }
    void SetBucket(std::unique_ptr<protocol::Storage::StorageBucket> value);  // Defined below

    String GetId() { return m_id; }
    void SetId(const String& value);  // Defined below

    double GetExpiration() { return m_expiration; }
    void SetExpiration(double value);  // Defined below

    double GetQuota() { return m_quota; }
    void SetQuota(double value);  // Defined below

    bool GetPersistent() { return m_persistent; }
    void SetPersistent(bool value);  // Defined below

    String GetDurability() { return m_durability; }
    void SetDurability(const String& value);  // Defined below

    template<int STATE>
    class StorageBucketInfoBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            BucketSet = 1 << 1,
            IdSet = 1 << 2,
            ExpirationSet = 1 << 3,
            QuotaSet = 1 << 4,
            PersistentSet = 1 << 5,
            DurabilitySet = 1 << 6,
            AllFieldsSet = (BucketSet | IdSet | ExpirationSet | QuotaSet | PersistentSet | DurabilitySet | 0)};


        StorageBucketInfoBuilder<STATE | BucketSet>& SetBucket(std::unique_ptr<protocol::Storage::StorageBucket> value);  // Defined below

        StorageBucketInfoBuilder<STATE | IdSet>& SetId(const String& value);  // Defined below

        StorageBucketInfoBuilder<STATE | ExpirationSet>& SetExpiration(double value);  // Defined below

        StorageBucketInfoBuilder<STATE | QuotaSet>& SetQuota(double value);  // Defined below

        StorageBucketInfoBuilder<STATE | PersistentSet>& SetPersistent(bool value);  // Defined below

        StorageBucketInfoBuilder<STATE | DurabilitySet>& SetDurability(const String& value);  // Defined below

        std::unique_ptr<StorageBucketInfo> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class StorageBucketInfo;
        StorageBucketInfoBuilder() : m_result(new StorageBucketInfo()) { }

        template<int STEP> StorageBucketInfoBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<StorageBucketInfoBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Storage::StorageBucketInfo> m_result;
    };

    static StorageBucketInfoBuilder<0> Create()
    {
        return StorageBucketInfoBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    StorageBucketInfo();  // Defined below

    std::unique_ptr<protocol::Storage::StorageBucket> m_bucket;
    String m_id;
    double m_expiration;
    double m_quota;
    bool m_persistent;
    String m_durability;
};


// ------------- Type and builder method definitions.
//
// These methods separate from the type declaration because of
// https://github.com/llvm/llvm-project/issues/59966. The DevTools protocol has
// mutually recursive types, so we cannot simply reorder the types.
inline UsageForType::~UsageForType() = default;
inline void UsageForType::SetStorageType(const String& value) { m_storageType = value; }
inline void UsageForType::SetUsage(double value) { m_usage = value; }

template<int STATE>
inline UsageForType::UsageForTypeBuilder<STATE | UsageForType::UsageForTypeBuilder<STATE>::StorageTypeSet>&
UsageForType::UsageForTypeBuilder<STATE>::SetStorageType(const String& value) {
  static_assert(!(STATE & StorageTypeSet), "property storageType should not be set yet");
  m_result->SetStorageType(value);
  return castState<StorageTypeSet>();
}
template<int STATE>
inline UsageForType::UsageForTypeBuilder<STATE | UsageForType::UsageForTypeBuilder<STATE>::UsageSet>&
UsageForType::UsageForTypeBuilder<STATE>::SetUsage(double value) {
  static_assert(!(STATE & UsageSet), "property usage should not be set yet");
  m_result->SetUsage(value);
  return castState<UsageSet>();
}

inline UsageForType::UsageForType() {
  m_usage = 0;
}
inline TrustTokens::~TrustTokens() = default;
inline void TrustTokens::SetIssuerOrigin(const String& value) { m_issuerOrigin = value; }
inline void TrustTokens::SetCount(double value) { m_count = value; }

template<int STATE>
inline TrustTokens::TrustTokensBuilder<STATE | TrustTokens::TrustTokensBuilder<STATE>::IssuerOriginSet>&
TrustTokens::TrustTokensBuilder<STATE>::SetIssuerOrigin(const String& value) {
  static_assert(!(STATE & IssuerOriginSet), "property issuerOrigin should not be set yet");
  m_result->SetIssuerOrigin(value);
  return castState<IssuerOriginSet>();
}
template<int STATE>
inline TrustTokens::TrustTokensBuilder<STATE | TrustTokens::TrustTokensBuilder<STATE>::CountSet>&
TrustTokens::TrustTokensBuilder<STATE>::SetCount(double value) {
  static_assert(!(STATE & CountSet), "property count should not be set yet");
  m_result->SetCount(value);
  return castState<CountSet>();
}

inline TrustTokens::TrustTokens() {
  m_count = 0;
}
inline StorageBucket::~StorageBucket() = default;
inline void StorageBucket::SetStorageKey(const String& value) { m_storageKey = value; }
inline void StorageBucket::SetName(const String& value) { m_name = value; }

template<int STATE>
inline StorageBucket::StorageBucketBuilder<STATE | StorageBucket::StorageBucketBuilder<STATE>::StorageKeySet>&
StorageBucket::StorageBucketBuilder<STATE>::SetStorageKey(const String& value) {
  static_assert(!(STATE & StorageKeySet), "property storageKey should not be set yet");
  m_result->SetStorageKey(value);
  return castState<StorageKeySet>();
}
template<int STATE>
inline StorageBucket::StorageBucketBuilder<STATE>& StorageBucket::StorageBucketBuilder<STATE>::SetName(const String& value) {
  m_result->SetName(value);
  return *this;
}

inline StorageBucket::StorageBucket() {
}
inline StorageBucketInfo::~StorageBucketInfo() = default;
inline void StorageBucketInfo::SetBucket(std::unique_ptr<protocol::Storage::StorageBucket> value) { m_bucket = std::move(value); }
inline void StorageBucketInfo::SetId(const String& value) { m_id = value; }
inline void StorageBucketInfo::SetExpiration(double value) { m_expiration = value; }
inline void StorageBucketInfo::SetQuota(double value) { m_quota = value; }
inline void StorageBucketInfo::SetPersistent(bool value) { m_persistent = value; }
inline void StorageBucketInfo::SetDurability(const String& value) { m_durability = value; }

template<int STATE>
inline StorageBucketInfo::StorageBucketInfoBuilder<STATE | StorageBucketInfo::StorageBucketInfoBuilder<STATE>::BucketSet>&
StorageBucketInfo::StorageBucketInfoBuilder<STATE>::SetBucket(std::unique_ptr<protocol::Storage::StorageBucket> value) {
  static_assert(!(STATE & BucketSet), "property bucket should not be set yet");
  m_result->SetBucket(std::move(value));
  return castState<BucketSet>();
}
template<int STATE>
inline StorageBucketInfo::StorageBucketInfoBuilder<STATE | StorageBucketInfo::StorageBucketInfoBuilder<STATE>::IdSet>&
StorageBucketInfo::StorageBucketInfoBuilder<STATE>::SetId(const String& value) {
  static_assert(!(STATE & IdSet), "property id should not be set yet");
  m_result->SetId(value);
  return castState<IdSet>();
}
template<int STATE>
inline StorageBucketInfo::StorageBucketInfoBuilder<STATE | StorageBucketInfo::StorageBucketInfoBuilder<STATE>::ExpirationSet>&
StorageBucketInfo::StorageBucketInfoBuilder<STATE>::SetExpiration(double value) {
  static_assert(!(STATE & ExpirationSet), "property expiration should not be set yet");
  m_result->SetExpiration(value);
  return castState<ExpirationSet>();
}
template<int STATE>
inline StorageBucketInfo::StorageBucketInfoBuilder<STATE | StorageBucketInfo::StorageBucketInfoBuilder<STATE>::QuotaSet>&
StorageBucketInfo::StorageBucketInfoBuilder<STATE>::SetQuota(double value) {
  static_assert(!(STATE & QuotaSet), "property quota should not be set yet");
  m_result->SetQuota(value);
  return castState<QuotaSet>();
}
template<int STATE>
inline StorageBucketInfo::StorageBucketInfoBuilder<STATE | StorageBucketInfo::StorageBucketInfoBuilder<STATE>::PersistentSet>&
StorageBucketInfo::StorageBucketInfoBuilder<STATE>::SetPersistent(bool value) {
  static_assert(!(STATE & PersistentSet), "property persistent should not be set yet");
  m_result->SetPersistent(value);
  return castState<PersistentSet>();
}
template<int STATE>
inline StorageBucketInfo::StorageBucketInfoBuilder<STATE | StorageBucketInfo::StorageBucketInfoBuilder<STATE>::DurabilitySet>&
StorageBucketInfo::StorageBucketInfoBuilder<STATE>::SetDurability(const String& value) {
  static_assert(!(STATE & DurabilitySet), "property durability should not be set yet");
  m_result->SetDurability(value);
  return castState<DurabilitySet>();
}

inline StorageBucketInfo::StorageBucketInfo() {
  m_expiration = 0;
  m_quota = 0;
  m_persistent = false;
}

// ------------- Backend interface.

class CONTENT_EXPORT Backend {
public:
    virtual ~Backend() { }

    virtual DispatchResponse GetStorageKeyForFrame(const String& in_frameId, String* out_storageKey) = 0;
    virtual DispatchResponse GetStorageKey(std::optional<String> in_frameId, String* out_storageKey) = 0;
    class CONTENT_EXPORT ClearDataForOriginCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ClearDataForOriginCallback() { }
    };
    virtual void ClearDataForOrigin(const String& in_origin, const String& in_storageTypes, std::unique_ptr<ClearDataForOriginCallback> callback) = 0;
    class CONTENT_EXPORT ClearDataForStorageKeyCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ClearDataForStorageKeyCallback() { }
    };
    virtual void ClearDataForStorageKey(const String& in_storageKey, const String& in_storageTypes, std::unique_ptr<ClearDataForStorageKeyCallback> callback) = 0;
    class CONTENT_EXPORT GetCookiesCallback {
    public:
        virtual void sendSuccess(std::unique_ptr<protocol::Array<protocol::Network::Cookie>> cookies) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~GetCookiesCallback() { }
    };
    virtual void GetCookies(std::optional<String> in_browserContextId, std::unique_ptr<GetCookiesCallback> callback) = 0;
    class CONTENT_EXPORT SetCookiesCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~SetCookiesCallback() { }
    };
    virtual void SetCookies(std::unique_ptr<protocol::Array<protocol::Network::CookieParam>> in_cookies, std::optional<String> in_browserContextId, std::unique_ptr<SetCookiesCallback> callback) = 0;
    class CONTENT_EXPORT ClearCookiesCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ClearCookiesCallback() { }
    };
    virtual void ClearCookies(std::optional<String> in_browserContextId, std::unique_ptr<ClearCookiesCallback> callback) = 0;
    class CONTENT_EXPORT GetUsageAndQuotaCallback {
    public:
        virtual void sendSuccess(double usage, double quota, bool overrideActive, std::unique_ptr<protocol::Array<protocol::Storage::UsageForType>> usageBreakdown) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~GetUsageAndQuotaCallback() { }
    };
    virtual void GetUsageAndQuota(const String& in_origin, std::unique_ptr<GetUsageAndQuotaCallback> callback) = 0;
    class CONTENT_EXPORT OverrideQuotaForOriginCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~OverrideQuotaForOriginCallback() { }
    };
    virtual void OverrideQuotaForOrigin(const String& in_origin, std::optional<double> in_quotaSize, std::unique_ptr<OverrideQuotaForOriginCallback> callback) = 0;
    virtual DispatchResponse TrackCacheStorageForOrigin(const String& in_origin) = 0;
    virtual DispatchResponse TrackCacheStorageForStorageKey(const String& in_storageKey) = 0;
    virtual DispatchResponse TrackIndexedDBForOrigin(const String& in_origin) = 0;
    virtual DispatchResponse TrackIndexedDBForStorageKey(const String& in_storageKey) = 0;
    virtual DispatchResponse UntrackCacheStorageForOrigin(const String& in_origin) = 0;
    virtual DispatchResponse UntrackCacheStorageForStorageKey(const String& in_storageKey) = 0;
    virtual DispatchResponse UntrackIndexedDBForOrigin(const String& in_origin) = 0;
    virtual DispatchResponse UntrackIndexedDBForStorageKey(const String& in_storageKey) = 0;
    class CONTENT_EXPORT GetTrustTokensCallback {
    public:
        virtual void sendSuccess(std::unique_ptr<protocol::Array<protocol::Storage::TrustTokens>> tokens) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~GetTrustTokensCallback() { }
    };
    virtual void GetTrustTokens(std::unique_ptr<GetTrustTokensCallback> callback) = 0;
    class CONTENT_EXPORT ClearTrustTokensCallback {
    public:
        virtual void sendSuccess(bool didDeleteTokens) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ClearTrustTokensCallback() { }
    };
    virtual void ClearTrustTokens(const String& in_issuerOrigin, std::unique_ptr<ClearTrustTokensCallback> callback) = 0;
    virtual DispatchResponse SetStorageBucketTracking(const String& in_storageKey, bool in_enable) = 0;
    virtual DispatchResponse DeleteStorageBucket(std::unique_ptr<protocol::Storage::StorageBucket> in_bucket) = 0;

    virtual DispatchResponse Disable()
    {
        return DispatchResponse::Success();
    }
};

// ------------- Frontend interface.

class CONTENT_EXPORT Frontend {
public:
  explicit Frontend(FrontendChannel* frontend_channel) : frontend_channel_(frontend_channel) {}
    void CacheStorageContentUpdated(const String& origin, const String& storageKey, const String& bucketId, const String& cacheName);
    void CacheStorageListUpdated(const String& origin, const String& storageKey, const String& bucketId);
    void IndexedDBContentUpdated(const String& origin, const String& storageKey, const String& bucketId, const String& databaseName, const String& objectStoreName);
    void IndexedDBListUpdated(const String& origin, const String& storageKey, const String& bucketId);
    void StorageBucketCreatedOrUpdated(std::unique_ptr<protocol::Storage::StorageBucketInfo> bucketInfo);
    void StorageBucketDeleted(const String& bucketId);

  void flush();
  void sendRawNotification(std::unique_ptr<Serializable>);
 private:
  FrontendChannel* frontend_channel_;
};

// ------------- Dispatcher.

class CONTENT_EXPORT Dispatcher {
public:
    static void wire(UberDispatcher*, Backend*);

private:
    Dispatcher() { }
};

// ------------- Metainfo.

class CONTENT_EXPORT Metainfo {
public:
    using BackendClass = Backend;
    using FrontendClass = Frontend;
    using DispatcherClass = Dispatcher;
    static const char domainName[];
    static const char commandPrefix[];
    static const char version[];
};

} // namespace Storage
} // namespace content
} // namespace protocol

#endif // !defined(content_protocol_Storage_h)