cdk8s-plus-32 2.0.0

package/lib/api-resource.js

@@ -0,0 +1,430 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonApiResource = exports.ApiResource = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Represents information about an API resource type.
+ */
+class ApiResource {
+    /**
+     * API resource information for a custom resource type.
+     */
+    static custom(options) {
+        return new ApiResource(options);
+    }
+    ;
+    constructor(options) {
+        this.apiGroup = options.apiGroup;
+        this.resourceType = options.resourceType;
+    }
+    asApiResource() {
+        return this;
+    }
+    asNonApiResource() {
+        return undefined;
+    }
+}
+exports.ApiResource = ApiResource;
+_a = JSII_RTTI_SYMBOL_1;
+ApiResource[_a] = { fqn: "cdk8s-plus-32.ApiResource", version: "2.0.0" };
+/**
+ * API resource information for Binding.
+ */
+ApiResource.BINDINGS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'bindings',
+});
+/**
+ * API resource information for ComponentStatus.
+ */
+ApiResource.COMPONENT_STATUSES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'componentstatuses',
+});
+/**
+ * API resource information for ConfigMap.
+ */
+ApiResource.CONFIG_MAPS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'configmaps',
+});
+/**
+ * API resource information for Endpoints.
+ */
+ApiResource.ENDPOINTS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'endpoints',
+});
+/**
+ * API resource information for Event.
+ */
+ApiResource.EVENTS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'events',
+});
+/**
+ * API resource information for LimitRange.
+ */
+ApiResource.LIMIT_RANGES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'limitranges',
+});
+/**
+ * API resource information for Namespace.
+ */
+ApiResource.NAMESPACES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'namespaces',
+});
+/**
+ * API resource information for Node.
+ */
+ApiResource.NODES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'nodes',
+});
+/**
+ * API resource information for PersistentVolumeClaim.
+ */
+ApiResource.PERSISTENT_VOLUME_CLAIMS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'persistentvolumeclaims',
+});
+/**
+ * API resource information for PersistentVolume.
+ */
+ApiResource.PERSISTENT_VOLUMES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'persistentvolumes',
+});
+/**
+ * API resource information for Pod.
+ */
+ApiResource.PODS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'pods',
+});
+/**
+ * API resource information for PodTemplate.
+ */
+ApiResource.POD_TEMPLATES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'podtemplates',
+});
+/**
+ * API resource information for ReplicationController.
+ */
+ApiResource.REPLICATION_CONTROLLERS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'replicationcontrollers',
+});
+/**
+ * API resource information for ResourceQuota.
+ */
+ApiResource.RESOURCE_QUOTAS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'resourcequotas',
+});
+/**
+ * API resource information for Secret.
+ */
+ApiResource.SECRETS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'secrets',
+});
+/**
+ * API resource information for ServiceAccount.
+ */
+ApiResource.SERVICE_ACCOUNTS = new ApiResource({
+    apiGroup: '',
+    resourceType: 'serviceaccounts',
+});
+/**
+ * API resource information for Service.
+ */
+ApiResource.SERVICES = new ApiResource({
+    apiGroup: '',
+    resourceType: 'services',
+});
+/**
+ * API resource information for MutatingWebhookConfiguration.
+ */
+ApiResource.MUTATING_WEBHOOK_CONFIGURATIONS = new ApiResource({
+    apiGroup: 'admissionregistration.k8s.io',
+    resourceType: 'mutatingwebhookconfigurations',
+});
+/**
+ * API resource information for ValidatingWebhookConfiguration.
+ */
+ApiResource.VALIDATING_WEBHOOK_CONFIGURATIONS = new ApiResource({
+    apiGroup: 'admissionregistration.k8s.io',
+    resourceType: 'validatingwebhookconfigurations',
+});
+/**
+ * API resource information for CustomResourceDefinition.
+ */
+ApiResource.CUSTOM_RESOURCE_DEFINITIONS = new ApiResource({
+    apiGroup: 'apiextensions.k8s.io',
+    resourceType: 'customresourcedefinitions',
+});
+/**
+ * API resource information for APIService.
+ */
+ApiResource.API_SERVICES = new ApiResource({
+    apiGroup: 'apiregistration.k8s.io',
+    resourceType: 'apiservices',
+});
+/**
+ * API resource information for ControllerRevision.
+ */
+ApiResource.CONTROLLER_REVISIONS = new ApiResource({
+    apiGroup: 'apps',
+    resourceType: 'controllerrevisions',
+});
+/**
+ * API resource information for DaemonSet.
+ */
+ApiResource.DAEMON_SETS = new ApiResource({
+    apiGroup: 'apps',
+    resourceType: 'daemonsets',
+});
+/**
+ * API resource information for Deployment.
+ */
+ApiResource.DEPLOYMENTS = new ApiResource({
+    apiGroup: 'apps',
+    resourceType: 'deployments',
+});
+/**
+ * API resource information for ReplicaSet.
+ */
+ApiResource.REPLICA_SETS = new ApiResource({
+    apiGroup: 'apps',
+    resourceType: 'replicasets',
+});
+/**
+ * API resource information for StatefulSet.
+ */
+ApiResource.STATEFUL_SETS = new ApiResource({
+    apiGroup: 'apps',
+    resourceType: 'statefulsets',
+});
+/**
+ * API resource information for TokenReview.
+ */
+ApiResource.TOKEN_REVIEWS = new ApiResource({
+    apiGroup: 'authentication.k8s.io',
+    resourceType: 'tokenreviews',
+});
+/**
+ * API resource information for LocalSubjectAccessReview.
+ */
+ApiResource.LOCAL_SUBJECT_ACCESS_REVIEWS = new ApiResource({
+    apiGroup: 'authorization.k8s.io',
+    resourceType: 'localsubjectaccessreviews',
+});
+/**
+ * API resource information for SelfSubjectAccessReview.
+ */
+ApiResource.SELF_SUBJECT_ACCESS_REVIEWS = new ApiResource({
+    apiGroup: 'authorization.k8s.io',
+    resourceType: 'selfsubjectaccessreviews',
+});
+/**
+ * API resource information for SelfSubjectRulesReview.
+ */
+ApiResource.SELF_SUBJECT_RULES_REVIEWS = new ApiResource({
+    apiGroup: 'authorization.k8s.io',
+    resourceType: 'selfsubjectrulesreviews',
+});
+/**
+ * API resource information for SubjectAccessReview.
+ */
+ApiResource.SUBJECT_ACCESS_REVIEWS = new ApiResource({
+    apiGroup: 'authorization.k8s.io',
+    resourceType: 'subjectaccessreviews',
+});
+/**
+ * API resource information for HorizontalPodAutoscaler.
+ */
+ApiResource.HORIZONTAL_POD_AUTOSCALERS = new ApiResource({
+    apiGroup: 'autoscaling',
+    resourceType: 'horizontalpodautoscalers',
+});
+/**
+ * API resource information for CronJob.
+ */
+ApiResource.CRON_JOBS = new ApiResource({
+    apiGroup: 'batch',
+    resourceType: 'cronjobs',
+});
+/**
+ * API resource information for Job.
+ */
+ApiResource.JOBS = new ApiResource({
+    apiGroup: 'batch',
+    resourceType: 'jobs',
+});
+/**
+ * API resource information for CertificateSigningRequest.
+ */
+ApiResource.CERTIFICATE_SIGNING_REQUESTS = new ApiResource({
+    apiGroup: 'certificates.k8s.io',
+    resourceType: 'certificatesigningrequests',
+});
+/**
+ * API resource information for Lease.
+ */
+ApiResource.LEASES = new ApiResource({
+    apiGroup: 'coordination.k8s.io',
+    resourceType: 'leases',
+});
+/**
+ * API resource information for EndpointSlice.
+ */
+ApiResource.ENDPOINT_SLICES = new ApiResource({
+    apiGroup: 'discovery.k8s.io',
+    resourceType: 'endpointslices',
+});
+/**
+ * API resource information for FlowSchema.
+ */
+ApiResource.FLOW_SCHEMAS = new ApiResource({
+    apiGroup: 'flowcontrol.apiserver.k8s.io',
+    resourceType: 'flowschemas',
+});
+/**
+ * API resource information for PriorityLevelConfiguration.
+ */
+ApiResource.PRIORITY_LEVEL_CONFIGURATIONS = new ApiResource({
+    apiGroup: 'flowcontrol.apiserver.k8s.io',
+    resourceType: 'prioritylevelconfigurations',
+});
+/**
+ * API resource information for IngressClass.
+ */
+ApiResource.INGRESS_CLASSES = new ApiResource({
+    apiGroup: 'networking.k8s.io',
+    resourceType: 'ingressclasses',
+});
+/**
+ * API resource information for Ingress.
+ */
+ApiResource.INGRESSES = new ApiResource({
+    apiGroup: 'networking.k8s.io',
+    resourceType: 'ingresses',
+});
+/**
+ * API resource information for NetworkPolicy.
+ */
+ApiResource.NETWORK_POLICIES = new ApiResource({
+    apiGroup: 'networking.k8s.io',
+    resourceType: 'networkpolicies',
+});
+/**
+ * API resource information for RuntimeClass.
+ */
+ApiResource.RUNTIME_CLASSES = new ApiResource({
+    apiGroup: 'node.k8s.io',
+    resourceType: 'runtimeclasses',
+});
+/**
+ * API resource information for PodDisruptionBudget.
+ */
+ApiResource.POD_DISRUPTION_BUDGETS = new ApiResource({
+    apiGroup: 'policy',
+    resourceType: 'poddisruptionbudgets',
+});
+/**
+ * API resource information for ClusterRoleBinding.
+ */
+ApiResource.CLUSTER_ROLE_BINDINGS = new ApiResource({
+    apiGroup: 'rbac.authorization.k8s.io',
+    resourceType: 'clusterrolebindings',
+});
+/**
+ * API resource information for ClusterRole.
+ */
+ApiResource.CLUSTER_ROLES = new ApiResource({
+    apiGroup: 'rbac.authorization.k8s.io',
+    resourceType: 'clusterroles',
+});
+/**
+ * API resource information for RoleBinding.
+ */
+ApiResource.ROLE_BINDINGS = new ApiResource({
+    apiGroup: 'rbac.authorization.k8s.io',
+    resourceType: 'rolebindings',
+});
+/**
+ * API resource information for Role.
+ */
+ApiResource.ROLES = new ApiResource({
+    apiGroup: 'rbac.authorization.k8s.io',
+    resourceType: 'roles',
+});
+/**
+ * API resource information for PriorityClass.
+ */
+ApiResource.PRIORITY_CLASSES = new ApiResource({
+    apiGroup: 'scheduling.k8s.io',
+    resourceType: 'priorityclasses',
+});
+/**
+ * API resource information for CSIDriver.
+ */
+ApiResource.CSI_DRIVERS = new ApiResource({
+    apiGroup: 'storage.k8s.io',
+    resourceType: 'csidrivers',
+});
+/**
+ * API resource information for CSINode.
+ */
+ApiResource.CSI_NODES = new ApiResource({
+    apiGroup: 'storage.k8s.io',
+    resourceType: 'csinodes',
+});
+/**
+ * API resource information for CSIStorageCapacity.
+ */
+ApiResource.CSI_STORAGE_CAPACITIES = new ApiResource({
+    apiGroup: 'storage.k8s.io',
+    resourceType: 'csistoragecapacities',
+});
+/**
+ * API resource information for StorageClass.
+ */
+ApiResource.STORAGE_CLASSES = new ApiResource({
+    apiGroup: 'storage.k8s.io',
+    resourceType: 'storageclasses',
+});
+/**
+ * API resource information for VolumeAttachment.
+ */
+ApiResource.VOLUME_ATTACHMENTS = new ApiResource({
+    apiGroup: 'storage.k8s.io',
+    resourceType: 'volumeattachments',
+});
+/**
+ * Factory for creating non api resources.
+ */
+class NonApiResource {
+    static of(url) {
+        return new NonApiResource(url);
+    }
+    constructor(nonResourceUrl) {
+        this.nonResourceUrl = nonResourceUrl;
+    }
+    ;
+    asApiResource() {
+        return undefined;
+    }
+    asNonApiResource() {
+        return this.nonResourceUrl;
+    }
+}
+exports.NonApiResource = NonApiResource;
+_b = JSII_RTTI_SYMBOL_1;
+NonApiResource[_b] = { fqn: "cdk8s-plus-32.NonApiResource", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-resource.js","sourceRoot":"","sources":["../src/api-resource.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Represents a resource or collection of resources.\n */\nexport interface IApiResource {\n  /**\n   * The group portion of the API version (e.g. `authorization.k8s.io`).\n   */\n  readonly apiGroup: string;\n\n  /**\n   * The name of a resource type as it appears in the relevant API endpoint.\n   * @example - \"pods\" or \"pods/log\"\n   * @see https://kubernetes.io/docs/reference/access-authn-authz/rbac/#referring-to-resources\n   */\n  readonly resourceType: string;\n\n  /**\n   * The unique, namespace-global, name of an object inside the Kubernetes cluster.\n   *\n   * If this is omitted, the ApiResource should represent all objects of the given type.\n   */\n  readonly resourceName?: string;\n}\n/**\n * An API Endpoint can either be a resource descriptor (e.g /pods)\n * or a non resource url (e.g /healthz). It must be one or the other, and not both.\n */\nexport interface IApiEndpoint {\n\n  /**\n   * Return the IApiResource this object represents.\n   */\n  asApiResource(): IApiResource | undefined;\n\n  /**\n   * Return the non resource url this object represents.\n   */\n  asNonApiResource(): string | undefined;\n\n}\n\n/**\n * Options for `ApiResource`.\n */\nexport interface ApiResourceOptions {\n  /**\n   * The group portion of the API version (e.g. `authorization.k8s.io`).\n   */\n  readonly apiGroup: string;\n\n  /**\n   * The name of the resource type as it appears in the relevant API endpoint.\n   * @example - \"pods\" or \"pods/log\"\n   * @see https://kubernetes.io/docs/reference/access-authn-authz/rbac/#referring-to-resources\n   */\n  readonly resourceType: string;\n}\n\n/**\n * Represents information about an API resource type.\n */\nexport class ApiResource implements IApiResource, IApiEndpoint {\n  /**\n   * API resource information for Binding.\n   */\n  public static readonly BINDINGS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'bindings',\n  });\n\n  /**\n   * API resource information for ComponentStatus.\n   */\n  public static readonly COMPONENT_STATUSES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'componentstatuses',\n  });\n\n  /**\n   * API resource information for ConfigMap.\n   */\n  public static readonly CONFIG_MAPS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'configmaps',\n  });\n\n  /**\n   * API resource information for Endpoints.\n   */\n  public static readonly ENDPOINTS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'endpoints',\n  });\n\n  /**\n   * API resource information for Event.\n   */\n  public static readonly EVENTS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'events',\n  });\n\n  /**\n   * API resource information for LimitRange.\n   */\n  public static readonly LIMIT_RANGES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'limitranges',\n  });\n\n  /**\n   * API resource information for Namespace.\n   */\n  public static readonly NAMESPACES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'namespaces',\n  });\n\n  /**\n   * API resource information for Node.\n   */\n  public static readonly NODES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'nodes',\n  });\n\n  /**\n   * API resource information for PersistentVolumeClaim.\n   */\n  public static readonly PERSISTENT_VOLUME_CLAIMS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'persistentvolumeclaims',\n  });\n\n  /**\n   * API resource information for PersistentVolume.\n   */\n  public static readonly PERSISTENT_VOLUMES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'persistentvolumes',\n  });\n\n  /**\n   * API resource information for Pod.\n   */\n  public static readonly PODS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'pods',\n  });\n\n  /**\n   * API resource information for PodTemplate.\n   */\n  public static readonly POD_TEMPLATES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'podtemplates',\n  });\n\n  /**\n   * API resource information for ReplicationController.\n   */\n  public static readonly REPLICATION_CONTROLLERS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'replicationcontrollers',\n  });\n\n  /**\n   * API resource information for ResourceQuota.\n   */\n  public static readonly RESOURCE_QUOTAS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'resourcequotas',\n  });\n\n  /**\n   * API resource information for Secret.\n   */\n  public static readonly SECRETS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'secrets',\n  });\n\n  /**\n   * API resource information for ServiceAccount.\n   */\n  public static readonly SERVICE_ACCOUNTS = new ApiResource({\n    apiGroup: '',\n    resourceType: 'serviceaccounts',\n  });\n\n  /**\n   * API resource information for Service.\n   */\n  public static readonly SERVICES = new ApiResource({\n    apiGroup: '',\n    resourceType: 'services',\n  });\n\n  /**\n   * API resource information for MutatingWebhookConfiguration.\n   */\n  public static readonly MUTATING_WEBHOOK_CONFIGURATIONS = new ApiResource({\n    apiGroup: 'admissionregistration.k8s.io',\n    resourceType: 'mutatingwebhookconfigurations',\n  });\n\n  /**\n   * API resource information for ValidatingWebhookConfiguration.\n   */\n  public static readonly VALIDATING_WEBHOOK_CONFIGURATIONS = new ApiResource({\n    apiGroup: 'admissionregistration.k8s.io',\n    resourceType: 'validatingwebhookconfigurations',\n  });\n\n  /**\n   * API resource information for CustomResourceDefinition.\n   */\n  public static readonly CUSTOM_RESOURCE_DEFINITIONS = new ApiResource({\n    apiGroup: 'apiextensions.k8s.io',\n    resourceType: 'customresourcedefinitions',\n  });\n\n  /**\n   * API resource information for APIService.\n   */\n  public static readonly API_SERVICES = new ApiResource({\n    apiGroup: 'apiregistration.k8s.io',\n    resourceType: 'apiservices',\n  });\n\n  /**\n   * API resource information for ControllerRevision.\n   */\n  public static readonly CONTROLLER_REVISIONS = new ApiResource({\n    apiGroup: 'apps',\n    resourceType: 'controllerrevisions',\n  });\n\n  /**\n   * API resource information for DaemonSet.\n   */\n  public static readonly DAEMON_SETS = new ApiResource({\n    apiGroup: 'apps',\n    resourceType: 'daemonsets',\n  });\n\n  /**\n   * API resource information for Deployment.\n   */\n  public static readonly DEPLOYMENTS = new ApiResource({\n    apiGroup: 'apps',\n    resourceType: 'deployments',\n  });\n\n  /**\n   * API resource information for ReplicaSet.\n   */\n  public static readonly REPLICA_SETS = new ApiResource({\n    apiGroup: 'apps',\n    resourceType: 'replicasets',\n  });\n\n  /**\n   * API resource information for StatefulSet.\n   */\n  public static readonly STATEFUL_SETS = new ApiResource({\n    apiGroup: 'apps',\n    resourceType: 'statefulsets',\n  });\n\n  /**\n   * API resource information for TokenReview.\n   */\n  public static readonly TOKEN_REVIEWS = new ApiResource({\n    apiGroup: 'authentication.k8s.io',\n    resourceType: 'tokenreviews',\n  });\n\n  /**\n   * API resource information for LocalSubjectAccessReview.\n   */\n  public static readonly LOCAL_SUBJECT_ACCESS_REVIEWS = new ApiResource({\n    apiGroup: 'authorization.k8s.io',\n    resourceType: 'localsubjectaccessreviews',\n  });\n\n  /**\n   * API resource information for SelfSubjectAccessReview.\n   */\n  public static readonly SELF_SUBJECT_ACCESS_REVIEWS = new ApiResource({\n    apiGroup: 'authorization.k8s.io',\n    resourceType: 'selfsubjectaccessreviews',\n  });\n\n  /**\n   * API resource information for SelfSubjectRulesReview.\n   */\n  public static readonly SELF_SUBJECT_RULES_REVIEWS = new ApiResource({\n    apiGroup: 'authorization.k8s.io',\n    resourceType: 'selfsubjectrulesreviews',\n  });\n\n  /**\n   * API resource information for SubjectAccessReview.\n   */\n  public static readonly SUBJECT_ACCESS_REVIEWS = new ApiResource({\n    apiGroup: 'authorization.k8s.io',\n    resourceType: 'subjectaccessreviews',\n  });\n\n  /**\n   * API resource information for HorizontalPodAutoscaler.\n   */\n  public static readonly HORIZONTAL_POD_AUTOSCALERS = new ApiResource({\n    apiGroup: 'autoscaling',\n    resourceType: 'horizontalpodautoscalers',\n  });\n\n  /**\n   * API resource information for CronJob.\n   */\n  public static readonly CRON_JOBS = new ApiResource({\n    apiGroup: 'batch',\n    resourceType: 'cronjobs',\n  });\n\n  /**\n   * API resource information for Job.\n   */\n  public static readonly JOBS = new ApiResource({\n    apiGroup: 'batch',\n    resourceType: 'jobs',\n  });\n\n  /**\n   * API resource information for CertificateSigningRequest.\n   */\n  public static readonly CERTIFICATE_SIGNING_REQUESTS = new ApiResource({\n    apiGroup: 'certificates.k8s.io',\n    resourceType: 'certificatesigningrequests',\n  });\n\n  /**\n   * API resource information for Lease.\n   */\n  public static readonly LEASES = new ApiResource({\n    apiGroup: 'coordination.k8s.io',\n    resourceType: 'leases',\n  });\n\n  /**\n   * API resource information for EndpointSlice.\n   */\n  public static readonly ENDPOINT_SLICES = new ApiResource({\n    apiGroup: 'discovery.k8s.io',\n    resourceType: 'endpointslices',\n  });\n\n  /**\n   * API resource information for FlowSchema.\n   */\n  public static readonly FLOW_SCHEMAS = new ApiResource({\n    apiGroup: 'flowcontrol.apiserver.k8s.io',\n    resourceType: 'flowschemas',\n  });\n\n  /**\n   * API resource information for PriorityLevelConfiguration.\n   */\n  public static readonly PRIORITY_LEVEL_CONFIGURATIONS = new ApiResource({\n    apiGroup: 'flowcontrol.apiserver.k8s.io',\n    resourceType: 'prioritylevelconfigurations',\n  });\n\n  /**\n   * API resource information for IngressClass.\n   */\n  public static readonly INGRESS_CLASSES = new ApiResource({\n    apiGroup: 'networking.k8s.io',\n    resourceType: 'ingressclasses',\n  });\n\n  /**\n   * API resource information for Ingress.\n   */\n  public static readonly INGRESSES = new ApiResource({\n    apiGroup: 'networking.k8s.io',\n    resourceType: 'ingresses',\n  });\n\n  /**\n   * API resource information for NetworkPolicy.\n   */\n  public static readonly NETWORK_POLICIES = new ApiResource({\n    apiGroup: 'networking.k8s.io',\n    resourceType: 'networkpolicies',\n  });\n\n  /**\n   * API resource information for RuntimeClass.\n   */\n  public static readonly RUNTIME_CLASSES = new ApiResource({\n    apiGroup: 'node.k8s.io',\n    resourceType: 'runtimeclasses',\n  });\n\n  /**\n   * API resource information for PodDisruptionBudget.\n   */\n  public static readonly POD_DISRUPTION_BUDGETS = new ApiResource({\n    apiGroup: 'policy',\n    resourceType: 'poddisruptionbudgets',\n  });\n\n  /**\n   * API resource information for ClusterRoleBinding.\n   */\n  public static readonly CLUSTER_ROLE_BINDINGS = new ApiResource({\n    apiGroup: 'rbac.authorization.k8s.io',\n    resourceType: 'clusterrolebindings',\n  });\n\n  /**\n   * API resource information for ClusterRole.\n   */\n  public static readonly CLUSTER_ROLES = new ApiResource({\n    apiGroup: 'rbac.authorization.k8s.io',\n    resourceType: 'clusterroles',\n  });\n\n  /**\n   * API resource information for RoleBinding.\n   */\n  public static readonly ROLE_BINDINGS = new ApiResource({\n    apiGroup: 'rbac.authorization.k8s.io',\n    resourceType: 'rolebindings',\n  });\n\n  /**\n   * API resource information for Role.\n   */\n  public static readonly ROLES = new ApiResource({\n    apiGroup: 'rbac.authorization.k8s.io',\n    resourceType: 'roles',\n  });\n\n  /**\n   * API resource information for PriorityClass.\n   */\n  public static readonly PRIORITY_CLASSES = new ApiResource({\n    apiGroup: 'scheduling.k8s.io',\n    resourceType: 'priorityclasses',\n  });\n\n  /**\n   * API resource information for CSIDriver.\n   */\n  public static readonly CSI_DRIVERS = new ApiResource({\n    apiGroup: 'storage.k8s.io',\n    resourceType: 'csidrivers',\n  });\n\n  /**\n   * API resource information for CSINode.\n   */\n  public static readonly CSI_NODES = new ApiResource({\n    apiGroup: 'storage.k8s.io',\n    resourceType: 'csinodes',\n  });\n\n  /**\n   * API resource information for CSIStorageCapacity.\n   */\n  public static readonly CSI_STORAGE_CAPACITIES = new ApiResource({\n    apiGroup: 'storage.k8s.io',\n    resourceType: 'csistoragecapacities',\n  });\n\n  /**\n   * API resource information for StorageClass.\n   */\n  public static readonly STORAGE_CLASSES = new ApiResource({\n    apiGroup: 'storage.k8s.io',\n    resourceType: 'storageclasses',\n  });\n\n  /**\n   * API resource information for VolumeAttachment.\n   */\n  public static readonly VOLUME_ATTACHMENTS = new ApiResource({\n    apiGroup: 'storage.k8s.io',\n    resourceType: 'volumeattachments',\n  });\n\n  /**\n   * API resource information for a custom resource type.\n   */\n  public static custom(options: ApiResourceOptions): ApiResource {\n    return new ApiResource(options);\n  };\n\n  /**\n   * The group portion of the API version (e.g. `authorization.k8s.io`).\n   */\n  public readonly apiGroup: string;\n\n  /**\n   * The name of the resource type as it appears in the relevant API endpoint.\n   * @example - \"pods\" or \"pods/log\"\n   * @see https://kubernetes.io/docs/reference/access-authn-authz/rbac/#referring-to-resources\n   */\n  public readonly resourceType: string;\n\n  private constructor(options: ApiResourceOptions) {\n    this.apiGroup = options.apiGroup;\n    this.resourceType = options.resourceType;\n  }\n\n  public asApiResource(): IApiResource | undefined {\n    return this;\n  }\n\n  public asNonApiResource(): string | undefined {\n    return undefined;\n  }\n}\n\n/**\n * Factory for creating non api resources.\n */\nexport class NonApiResource implements IApiEndpoint {\n\n  public static of(url: string): NonApiResource {\n    return new NonApiResource(url);\n  }\n\n  private constructor(private readonly nonResourceUrl: string) {};\n\n  public asApiResource(): IApiResource | undefined {\n    return undefined;\n  }\n\n  public asNonApiResource(): string | undefined {\n\n    return this.nonResourceUrl;\n  }\n}"]}

package/lib/base.d.ts

@@ -0,0 +1,79 @@
+import { ApiObjectMetadata, ApiObject, ApiObjectMetadataDefinition } from 'cdk8s';
+import { Construct, IConstruct } from 'constructs';
+import { IApiResource, IApiEndpoint } from './api-resource';
+/**
+ * Initialization properties for resources.
+ */
+export interface ResourceProps {
+    /**
+     * Metadata that all persisted resources must have, which includes all objects
+     * users must create.
+     */
+    readonly metadata?: ApiObjectMetadata;
+}
+/**
+ * Represents a resource.
+ */
+export interface IResource extends IConstruct, IApiResource {
+    /**
+     * The Kubernetes name of this resource.
+     */
+    readonly name: string;
+    /**
+     * The object's API version (e.g. "authorization.k8s.io/v1")
+     */
+    readonly apiVersion: string;
+    /**
+     * The object kind (e.g. "Deployment").
+     */
+    readonly kind: string;
+}
+/**
+ * Base class for all Kubernetes objects in stdk8s. Represents a single
+ * resource.
+ */
+export declare abstract class Resource extends Construct implements IResource, IApiResource, IApiEndpoint {
+    /**
+     * The underlying cdk8s API object.
+     */
+    protected abstract readonly apiObject: ApiObject;
+    abstract readonly resourceType: string;
+    readonly permissions: ResourcePermissions;
+    constructor(scope: Construct, id: string);
+    get metadata(): ApiObjectMetadataDefinition;
+    /**
+     * The name of this API object.
+     */
+    get name(): string;
+    /**
+     * The object's API version (e.g. "authorization.k8s.io/v1")
+     */
+    get apiVersion(): string;
+    /**
+     * The group portion of the API version (e.g. "authorization.k8s.io").
+     */
+    get apiGroup(): string;
+    /**
+     * The object kind (e.g. "Deployment").
+     */
+    get kind(): string;
+    get resourceName(): string | undefined;
+    asApiResource(): IApiResource | undefined;
+    asNonApiResource(): string | undefined;
+}
+/**
+ * Controls permissions for operations on resources.
+ */
+export declare class ResourcePermissions {
+    protected readonly instance: Resource;
+    constructor(instance: Resource);
+    /**
+     * Grants the list of subjects permissions to read this resource.
+     */
+    grantRead(...subjects: rb.ISubject[]): rb.RoleBinding;
+    /**
+     * Grants the list of subjects permissions to read and write this resource.
+     */
+    grantReadWrite(...subjects: rb.ISubject[]): rb.RoleBinding;
+}
+import * as rb from './role-binding';

package/lib/base.js

@@ -0,0 +1,92 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePermissions = exports.Resource = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constructs_1 = require("constructs");
+/**
+ * Base class for all Kubernetes objects in stdk8s. Represents a single
+ * resource.
+ */
+class Resource extends constructs_1.Construct {
+    constructor(scope, id) {
+        super(scope, id);
+        this.permissions = new ResourcePermissions(this);
+    }
+    get metadata() {
+        return this.apiObject.metadata;
+    }
+    /**
+     * The name of this API object.
+     */
+    get name() {
+        return this.apiObject.name;
+    }
+    /**
+     * The object's API version (e.g. "authorization.k8s.io/v1")
+     */
+    get apiVersion() {
+        return this.apiObject.apiVersion;
+    }
+    /**
+     * The group portion of the API version (e.g. "authorization.k8s.io").
+     */
+    get apiGroup() {
+        return this.apiObject.apiGroup;
+    }
+    /**
+     * The object kind (e.g. "Deployment").
+     */
+    get kind() {
+        return this.apiObject.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+    asApiResource() {
+        return this;
+    }
+    asNonApiResource() {
+        return undefined;
+    }
+}
+exports.Resource = Resource;
+_a = JSII_RTTI_SYMBOL_1;
+Resource[_a] = { fqn: "cdk8s-plus-32.Resource", version: "2.0.0" };
+/**
+ * Controls permissions for operations on resources.
+ */
+class ResourcePermissions {
+    constructor(instance) {
+        this.instance = instance;
+    }
+    /**
+     * Grants the list of subjects permissions to read this resource.
+     */
+    grantRead(...subjects) {
+        const subjectsAddress = (0, utils_1.address)(...subjects);
+        const role = new r.Role(this.instance, `Role${subjectsAddress}`, {
+            metadata: { namespace: this.instance.metadata.namespace },
+        });
+        role.allowRead(this.instance);
+        return role.bind(...subjects);
+    }
+    /**
+     * Grants the list of subjects permissions to read and write this resource.
+     */
+    grantReadWrite(...subjects) {
+        const subjectsAddress = (0, utils_1.address)(...subjects);
+        const role = new r.Role(this.instance, `Role${subjectsAddress}`, {
+            metadata: { namespace: this.instance.metadata.namespace },
+        });
+        role.allowReadWrite(this.instance);
+        return role.bind(...subjects);
+    }
+}
+exports.ResourcePermissions = ResourcePermissions;
+_b = JSII_RTTI_SYMBOL_1;
+ResourcePermissions[_b] = { fqn: "cdk8s-plus-32.ResourcePermissions", version: "2.0.0" };
+// meh, avoiding errors due to circular imports...
+const r = require("./role");
+const utils_1 = require("./utils");
+//# sourceMappingURL=data:application/json;base64,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