cdk8s-plus-31 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 {
+    constructor(options) {
+        this.apiGroup = options.apiGroup;
+        this.resourceType = options.resourceType;
+    }
+    /**
+     * API resource information for a custom resource type.
+     */
+    static custom(options) {
+        return new ApiResource(options);
+    }
+    ;
+    asApiResource() {
+        return this;
+    }
+    asNonApiResource() {
+        return undefined;
+    }
+}
+exports.ApiResource = ApiResource;
+_a = JSII_RTTI_SYMBOL_1;
+ApiResource[_a] = { fqn: "cdk8s-plus-31.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 {
+    constructor(nonResourceUrl) {
+        this.nonResourceUrl = nonResourceUrl;
+    }
+    static of(url) {
+        return new NonApiResource(url);
+    }
+    ;
+    asApiResource() {
+        return undefined;
+    }
+    asNonApiResource() {
+        return this.nonResourceUrl;
+    }
+}
+exports.NonApiResource = NonApiResource;
+_b = JSII_RTTI_SYMBOL_1;
+NonApiResource[_b] = { fqn: "cdk8s-plus-31.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-31.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 = 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 = 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-31.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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