// Monolithic services can use directly (WorkerId defaults to 0)
zid.NextInt()           // → 1222633405189
zid.NextString()        // → "1222633405189"
zid.NextHex()           // → "11caaa13805" (hexadecimal)
zid.NextBase36()        // → "flo4d0n9" (Base36, short ID, case-insensitive)
zid.NextBase62()        // → "lwyFau1" (Base62, even shorter ID, case-sensitive)

// Want even shorter IDs? Customize WorkerIdBitLength and SeqBitLength.
// SeqBitLength affects QPS. If unsure, refer to test cases to find the best fit for your scenario.
// Shortest ID is achieved by setting BaseTime as late as possible, WorkerIdBitLength='f', and SeqBitLength=3.

// Parse ID information
zid.ExtractTime(id)           // → time.Time
zid.ExtractWorkerId(id)       // → int64
// Parsing also supports Hex / Base36 / Base62
zid.ExtractTimeHex("...")
zid.ExtractWorkerIdHex("...")

// Override global configuration (e.g., custom WorkerId or performance tuning)
zid.WithOptions(&zid.Options{"..."})
id := idGen.NextId()

// Create a separate instance, isolated from the global generator
idGen := NewDefaultIdGenerator(&zid.Options{"..."})
id := idGen.NextId()

// Create a sharded instance
idGen := NewShardedGenerator(&zid.Options{"..."})
id := idGen.NextId()

// Increase WorkerIdBitLength, e.g., to 19 → supports up to 524,288 nodes
// You must balance WorkerIdBitLength and SeqBitLength yourself

// Option 1: Disable WorkerId entirely by setting WorkerIdBitLength='f'
// WorkerId bits are fully reallocated to SeqBitLength (22 bits), ensuring near-monotonic IDs
zid.WithOptions(&Options{
    WorkerIdBitLength: 'f',
    SeqBitLength:      22,
})

// Option 2: Option 1 uses locking, which degrades performance under concurrency.
// For concurrent scenarios, enable sharded mode for lock-free, allocation-free, atomic-free routing
// Uses fastrand for significantly higher concurrency performance; IDs remain roughly monotonic per millisecond
zid.WithOptions(&Options{
    WorkerIdBitLength: 16,
    SeqBitLength:      6,
    ShardedMode:       true,
})

zid.WithOptionsAndWorkerManager(
    zidredis.NewRedisManager(r redis.UniversalClient),
    &zid.Options{},
)
id := zid.NextId()

// You can also specify a key prefix
zid.WithOptionsAndWorkerManager(
    zidredis.NewRedisManager(r redis.UniversalClient, "zid"),
    &zid.Options{},
)

zid.WithOptionsAndWorkerManager(
    zidk8s.NewKubernetesManager(&zid.KubernetesOptions{
        PodUID          string // Auto-read from POD_UID env var if unset
        Namespace       string // Auto-read from NAMESPACE env var if unset
        LeaseNamePrefix string // Defaults to "snowflake-" if unset
        Config          *rest.Config // Auto-read from InClusterConfig() if unset
    }),
    &zid.Options{},
)
id := zid.NextId()

// Just implement the WorkerIdManager interface
type WorkerIdManager interface {
    Acquire(ctx context.Context, max int64) error // Acquire a WorkerId
    StartRenewal()  // Start auto-renewal
    Stop()          // Stop
    GetWorkerId() int64
}

// Example: Auto-assign based on IP + MAC
type IpMACWorkerIdManager struct {
    workerId int64
}
func NewIPMACWorkerIdManager() WorkerIdManager {
    return &IpMACWorkerIdManager{}
}
func (m *IpMACWorkerIdManager) Acquire(ctx context.Context, max int64) error{
    ip, mac := getPrimaryIPAndMAC()
    key := ip + "|" + mac
    hash := sha256.Sum256([]byte(key))
    m.workerId = int64(binary.BigEndian.Uint64(hash[:8]) % uint64(max+1))
    return nil
}
func (m *IpMACWorkerIdManager) StartRenewal() {}
func (m *IpMACWorkerIdManager) Stop() {}
func (m *IpMACWorkerIdManager) GetWorkerId() int64 {
    return m.workerId
}