All = collection.NewSchemasBuilder().
		MustAdd(AuthorizationPolicy).
		MustAdd(DestinationRule).
		MustAdd(Gateway).
		MustAdd(MeshConfig).
		MustAdd(MeshNetworks).
		MustAdd(PeerAuthentication).
		MustAdd(ProxyConfig).
		MustAdd(RequestAuthentication).
		MustAdd(ServiceEntry).
		MustAdd(Sidecar).
		MustAdd(Telemetry).
		MustAdd(VirtualService).
		MustAdd(WasmPlugin).
		MustAdd(WorkloadEntry).

		MustAdd(ConfigMap).
		MustAdd(CustomResourceDefinition).
		MustAdd(DaemonSet).
		MustAdd(Deployment).
		MustAdd(EndpointSlice).
		MustAdd(Endpoints).
		MustAdd(GRPCRoute).
		MustAdd(GatewayClass).
		MustAdd(HTTPRoute).
		MustAdd(Ingress).
		MustAdd(IngressClass).
		MustAdd(KubernetesGateway).
		MustAdd(Lease).
		MustAdd(MutatingWebhookConfiguration).
		MustAdd(Namespace).
		MustAdd(Node).
		MustAdd(Pod).

	All = collection.NewSchemasBuilder().
	{{- range .Entries }}
		MustAdd({{ .Resource.Identifier }}).
	{{- end }}
		Build()

	// Kube contains only kubernetes collections.
	Kube = collection.NewSchemasBuilder().
	{{- range .Entries }}
		{{- if or (contains .Resource.Group "k8s.io") .Resource.Builtin  }}
		MustAdd({{ .Resource.Identifier }}).
		{{- end }}
	{{- end }}
		Build()

	b.schemas.byCollection[s.GroupVersionKind()] = s
	b.schemas.byAddOrder = append(b.schemas.byAddOrder, s)
	return nil
}

// MustAdd calls Add and panics if it fails.
func (b *SchemasBuilder) MustAdd(s resource.Schema) *SchemasBuilder {
	if err := b.Add(s); err != nil {
		panic(fmt.Sprintf("SchemasBuilder.MustAdd: %v", err))
	}
	return b
}

// Build a new schemas from this SchemasBuilder.
func (b *SchemasBuilder) Build() Schemas {

		g.Expect(r).To(BeNil())
	}()
	b := collection.NewSchemasBuilder()

	b.MustAdd(emptyResource)
}

func TestSchemas_MustRegister_Panic(t *testing.T) {
	g := NewWithT(t)
	defer func() {
		r := recover()
		g.Expect(r).NotTo(BeNil())
	}()
	b := collection.NewSchemasBuilder()

	b.MustAdd(emptyResource)
	b.MustAdd(emptyResource)
}

func TestSchema_FindByGroupVersionKind(t *testing.T) {
	g := NewWithT(t)

	g.Expect(a.Metadata().Inputs).To(ConsistOf(col1.GroupVersionKind(), col2.GroupVersionKind(), col3.GroupVersionKind(), col4.GroupVersionKind()))

	removed := a.RemoveSkipped(collection.NewSchemasBuilder().MustAdd(col1).MustAdd(col2).Build())

	g.Expect(removed).To(ConsistOf(a3.Metadata().Name, a4.Metadata().Name))
	g.Expect(a.Metadata().Inputs).To(ConsistOf(col1.GroupVersionKind(), col2.GroupVersionKind()))

	a.Analyze(&context{})

				return nil, errors.New("empty key")
			}
			return nil, nil
		},
	}.MustBuild()

	// Mocks is a Schemas containing the Mock Schema.
	Mocks = collection.NewSchemasBuilder().MustAdd(Mock).Build()

	}); err != nil {
		t.Fatalf("Create => got %v", err)
	}

	return pb
}

// Ensure that the client can run without CRDs present
func TestClientNoCRDs(t *testing.T) {
	schema := collection.NewSchemasBuilder().MustAdd(collections.Sidecar).Build()
	store, _ := makeClient(t, schema, nil)
	retry.UntilOrFail(t, store.HasSynced, retry.Timeout(time.Second))
	r := collections.VirtualService
	configMeta := config.Meta{
		Name:             "name",

	log.Infof("Creating WorkloadEntry only config store for %s", opts.ClusterID)
	workloadEntriesSchemas := collection.NewSchemasBuilder().
		MustAdd(collections.WorkloadEntry).
		Build()
	crdOpts := crdclient.Option{Revision: revision, DomainSuffix: opts.DomainSuffix, Identifier: "mc-workload-entry-controller"}

	}
}

func (sa *IstiodAnalyzer) Schemas() collection.Schemas {
	result := collection.NewSchemasBuilder()
	for _, store := range sa.stores {
		for _, schema := range store.Schemas().All() {
			result.MustAdd(schema)
		}
	}
	return result.Build()
}

func (sa *IstiodAnalyzer) addRunningKubeIstioConfigMapSource(client kubelib.Client) error {