type StatefulSetOrdinalsApplyConfiguration struct {
	Start *int32 `json:"start,omitempty"`
}

// StatefulSetOrdinalsApplyConfiguration constructs an declarative configuration of the StatefulSetOrdinals type for use with
// apply.
func StatefulSetOrdinals() *StatefulSetOrdinalsApplyConfiguration {
	return &StatefulSetOrdinalsApplyConfiguration{}
}

// WithStart sets the Start field in the declarative configuration to the given value

                    baseName.append(name.substring(start + 1, end));
                } else {
                    baseName.append(name.substring(start, end));
                    lowerBaseName.append('-');
                }
                lowerBaseName.append(Character.toLowerCase(name.charAt(start)));
                lowerBaseName.append(name.substring(start + 1, end));

```

## Running a Monitor

Once created, you simply run the monitor, providing a stop channel.

```golang
stop := make(chan struct{})
...
monitor.Start(stop)
```

The `Start` method will kick off an asynchronous polling loop and will return immediately.

## Example

To configure and run a monitor that watches for file changes to update an in-memory config store:

```golang

  my ($class) = @_;
  my $regexp = "[$class]";
  my $start = -1;
  for (my $i=0; $i<=129; $i++) {
    if ($i == 129) { $i = 256; }
    if ($i <= 128 && ($overrides{"$class:$i"} // chr($i) =~ $regexp)) {
      if ($start < 0) {
        $start = $i;
      }
    } else {
      if ($start >= 0) {
        push @ranges, [$start, $i-1];
      }
      $start = -1;
    }
  }
  return @ranges;
}

        when:
        start(cacheAccessWorker)
        cacheAccessWorker.flush()

        then:
        counter == 3

        cleanup:
        cacheAccessWorker?.stop()
    }

    def "flush rethrows action failure"() {
        def failure = new RuntimeException()
        cacheAccessWorker.enqueue { throw failure }

        when:
        start(cacheAccessWorker)

		}
		done <- struct{}{}
	}()

	// Give the goroutine ample chance to block on the pipe.
	time.Sleep(10 * time.Millisecond)

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

	// This isn't enough to have a full generation pass by default,
	// but it is generally enough in stress mode.
	time.Sleep(100 * time.Millisecond)

	"runtime/trace"
	"time"
)

func main() {
	// Start a goroutine that calls runtime.GC to try and
	// introduce some interesting events in between the
	// GOMAXPROCS calls.
	go func() {
		for {
			runtime.GC()
			time.Sleep(1 * time.Millisecond)
		}
	}()

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

	Informer cache.SharedIndexInformer
	start    func(stopCh <-chan struct{})
}

func (s StartableInformer) Start(stopCh <-chan struct{}) {
	s.start(stopCh)
}

// InformerFactory provides access to a shared informer factory
type InformerFactory interface {
	// Start initializes all requested informers. They are handled in goroutines
	// which run until the stop channel gets closed.
	Start(stopCh <-chan struct{})

            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().then(response -> latch.countDown());
        assertTrue(latch.await(10, TimeUnit.SECONDS));
    }

    @Test

		if start < 0 {
			return 0, 0, errors.New("ScanRange: Start after EOF")
		}
		return start, -1, nil
	}
	if s.Start == nil {
		// Suffix length
		end := int64(*s.End)
		if end < 0 {
			return 0, 0, errors.New("ScanRange: End bigger than file")
		}
		// Suffix length
		return -end, -1, nil
	}
	start = int64(*s.Start)
	end := int64(*s.End)
	return start, end - start + 1, nil
}